DUMMY_IP, DUMMY_TOKEN, UNIT_MAPPING, ) from collections import OrderedDict TYPE = 'sensor' _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = "Generic MIoT " + TYPE DATA_KEY = TYPE + '.' + DOMAIN CONF_SENSOR_PROPERTY = "sensor_property" CONF_SENSOR_UNIT = "sensor_unit" CONF_DEFAULT_PROPERTIES = "default_properties" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(SCHEMA) ATTR_PROPERTIES = "properties" ATTR_SENSOR_PROPERTY = "sensor_property" SCAN_INTERVAL = timedelta(seconds=5) DEVCLASS_MAPPING = { "battery": ["battery"], "humidity": ["humidity"], "illuminance": ["illuminance"], "signal_strength": ["signal_strength"], "temperature": ["temperature"], "timestamp": ["timestamp"], "power": ["electric_power"], "pressure": ["pressure"], "current": ["electric_current"],
CONF_CATEGORIES = 'categories' DEFAULT_ICON = 'mdi:alert' DEFAULT_NAME = "Event Service" 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_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(hass, config, add_entities, discovery_info=None): """Set up the GeoRSS component.""" home_latitude = hass.config.latitude home_longitude = hass.config.longitude url = config.get(CONF_URL) radius_in_km = config.get(CONF_RADIUS) name = config.get(CONF_NAME) categories = config.get(CONF_CATEGORIES) unit_of_measurement = config.get(CONF_UNIT_OF_MEASUREMENT)
'before_offpeak_upload': ['Upload before offpeak', GIGABITS, 'mdi:upload'], 'before_offpeak_total': ['Total before offpeak', GIGABITS, 'mdi:download'], 'offpeak_download': ['Offpeak download', GIGABITS, 'mdi:download'], 'offpeak_upload': ['Offpeak Upload', GIGABITS, 'mdi:upload'], 'offpeak_total': ['Offpeak Total', GIGABITS, 'mdi:download'], 'download': ['Download', GIGABITS, 'mdi:download'], 'upload': ['Upload', GIGABITS, 'mdi:upload'], 'total': ['Total', GIGABITS, 'mdi:download'], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_MONITORED_VARIABLES): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the EBox sensor.""" username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) httpsession = hass.helpers.aiohttp_client.async_get_clientsession() ebox_data = EBoxData(username, password, httpsession) name = config.get(CONF_NAME)
ATTR_SAMPLING_SIZE = 'sampling_size' ATTR_TOTAL = 'total' ATTR_MAX_AGE = 'max_age' ATTR_MIN_AGE = 'min_age' CONF_SAMPLING_SIZE = 'sampling_size' CONF_MAX_AGE = 'max_age' DEFAULT_NAME = 'Stats' DEFAULT_SIZE = 20 ICON = 'mdi:calculator' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ENTITY_ID): cv.entity_id, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_SAMPLING_SIZE, default=DEFAULT_SIZE): vol.All(vol.Coerce(int), vol.Range(min=1)), vol.Optional(CONF_MAX_AGE): cv.time_period }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the Statistics sensor.""" entity_id = config.get(CONF_ENTITY_ID) name = config.get(CONF_NAME) sampling_size = config.get(CONF_SAMPLING_SIZE) max_age = config.get(CONF_MAX_AGE, None) async_add_devices( [StatisticsSensor(hass, entity_id, name, sampling_size, max_age)],
vol.Required(CONF_NAME): cv.string, vol.Required(CONF_MEASUREMENT_NAME): cv.string, vol.Required(CONF_WHERE): cv.template, vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_DB_NAME, default=DEFAULT_DATABASE): cv.string, vol.Optional(CONF_GROUP_FUNCTION, default=DEFAULT_GROUP_FUNCTION): cv.string, vol.Optional(CONF_FIELD, default=DEFAULT_FIELD): cv.string }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_QUERIES): [_QUERY_SCHEME], vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Inclusive(CONF_USERNAME, 'authentication'): cv.string, vol.Inclusive(CONF_PASSWORD, 'authentication'): cv.string, vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean, vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean }) # Return cached results if last scan was less then this time ago MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the InfluxDB component.""" influx_conf = { 'host': config[CONF_HOST], 'password': config.get(CONF_PASSWORD), 'port': config.get(CONF_PORT),
STATE_VALUE = 'value' STATE_OBJECT = 'object' CONF_INTERVAL = 'interval' MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=15) SCAN_INTERVAL = timedelta(seconds=30) RETRY_INTERVAL = timedelta(seconds=30) OHM_VALUE = 'Value' OHM_MIN = 'Min' OHM_MAX = 'Max' OHM_CHILDREN = 'Children' OHM_NAME = 'Text' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_PORT, default=8085): cv.port }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Open Hardware Monitor platform.""" data = OpenHardwareMonitorData(config, hass) add_entities(data.devices, True) class OpenHardwareMonitorDevice(Entity): """Device used to display information from OpenHardwareMonitor.""" def __init__(self, data, name, path, unit_of_measurement): """Initialize an OpenHardwareMonitor sensor.""" self._name = name
REQUIREMENTS = ['python-sochain-api==0.0.2'] _LOGGER = logging.getLogger(__name__) CONF_ADDRESS = 'address' CONF_NETWORK = 'network' CONF_ATTRIBUTION = "Data provided by chain.so" DEFAULT_NAME = 'Crypto Balance' SCAN_INTERVAL = timedelta(minutes=5) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ADDRESS): cv.string, vol.Required(CONF_NETWORK): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the sochain sensors.""" from pysochain import ChainSo address = config.get(CONF_ADDRESS) network = config.get(CONF_NETWORK) name = config.get(CONF_NAME) session = async_get_clientsession(hass) chainso = ChainSo(network, address, hass.loop, session)
"Current Warning Level", None, "mdi:close-octagon-outline", ], "advance_warning_level": [ "Advance Warning Level", None, "mdi:close-octagon-outline", ], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_REGION_NAME): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_MONITORED_CONDITIONS, default=list(MONITORED_CONDITIONS)): vol.All(cv.ensure_list, [vol.In(MONITORED_CONDITIONS)]), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the DWD-Weather-Warnings sensor.""" name = config.get(CONF_NAME) region_name = config.get(CONF_REGION_NAME) api = DwdWeatherWarningsAPI(region_name) sensors = [ DwdWeatherWarningsSensor(api, name, condition)
"Circle", "District", "DLR", "Hammersmith & City", "Jubilee", "London Overground", "Metropolitan", "Northern", "Piccadilly", "TfL Rail", "Victoria", "Waterloo & City", ] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_LINE): vol.All(cv.ensure_list, [vol.In(list(TUBE_LINES))])} ) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Tube sensor.""" data = TubeData() data.update() sensors = [] for line in config.get(CONF_LINE): sensors.append(LondonTubeSensor(line, data)) add_entities(sensors, True)
from homeassistant.util import Throttle from . import cox_login, async_call_api _LOGGER = logging.getLogger(__name__) DATA_USAGE_URL = 'https://www.cox.com/internet/mydatausage.cox' DEFAULT_ICON = 'mdi:chart-line' MIN_TIME_BETWEEN_UPDATES = dt.timedelta(minutes=60) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default='Cox'): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string }) ATTR_USED_DATA = 'Used data' ATTR_TOTAL_DATA = 'Total data' ATTR_DAYS_IN_MONTH = 'Days this month' ATTR_DAYS_LEFT = 'Days Left in Cycle' ATTR_UTILIZATION = 'Percentage Used' ATTR_CURRENT_AVG_GB = 'Average GB Used Per Day' ATTR_REMAINING_AVG_GB = 'Average GB Remaining Per Day' async def async_setup_platform(hass, config,
import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity import Entity _LOGGER = logging.getLogger(__name__) ATTRIBUTION = "Data provided by WorldTides" DEFAULT_NAME = 'WorldTidesInfo' SCAN_INTERVAL = timedelta(seconds=3600) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Optional(CONF_LATITUDE): cv.latitude, vol.Optional(CONF_LONGITUDE): cv.longitude, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the WorldTidesInfo sensor.""" name = config.get(CONF_NAME) lat = config.get(CONF_LATITUDE, hass.config.latitude) lon = config.get(CONF_LONGITUDE, hass.config.longitude) key = config.get(CONF_API_KEY) if None in (lat, lon):
CONF_STOP_ID = 'stop_id' CONF_ROUTE = 'route' CONF_DIRECTION = 'direction' CONF_DEPARTURE_TYPE = 'departure_type' DEFAULT_NAME = 'Next departure' ICON = 'mdi:bus' SCAN_INTERVAL = timedelta(minutes=1) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_STOP_ID): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_ROUTE, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_DIRECTION, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_DEPARTURE_TYPE, default=[]): vol.All(cv.ensure_list, [vol.In(list(['BUS', 'EXB', 'M', 'S', 'REG']))]) }) def due_in_minutes(timestamp): """Get the time in minutes from a timestamp. The timestamp should be in the format day.month.year hour:minute """ diff = datetime.strptime( timestamp, "%d.%m.%y %H:%M") - dt_util.now().replace(tzinfo=None)
ATTR_POWER_GENERATION = "power_generation" ATTR_ENERGY_CONSUMPTION = "energy_consumption" ATTR_POWER_CONSUMPTION = "power_consumption" ATTR_EFFICIENCY = "efficiency" CONF_SYSTEM_ID = "system_id" DEFAULT_NAME = "PVOutput" DEFAULT_VERIFY_SSL = True SCAN_INTERVAL = timedelta(minutes=2) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_SYSTEM_ID): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, } ) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the PVOutput sensor.""" name = config.get(CONF_NAME) api_key = config.get(CONF_API_KEY) system_id = config.get(CONF_SYSTEM_ID) method = "GET" payload = auth = None verify_ssl = DEFAULT_VERIFY_SSL headers = {"X-Pvoutput-Apikey": api_key, "X-Pvoutput-SystemId": system_id}
from homeassistant.helpers.event import async_track_state_change _LOGGER = logging.getLogger(__name__) SENSOR_SCHEMA = vol.Schema({ vol.Required(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_ICON_TEMPLATE): cv.template, vol.Optional(CONF_ENTITY_PICTURE_TEMPLATE): cv.template, vol.Optional(CONF_FRIENDLY_NAME_TEMPLATE): cv.template, vol.Optional(ATTR_FRIENDLY_NAME): cv.string, vol.Optional(ATTR_UNIT_OF_MEASUREMENT): cv.string, vol.Optional(ATTR_ENTITY_ID): cv.entity_ids }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_SENSORS): vol.Schema({cv.slug: SENSOR_SCHEMA}), }) @asyncio.coroutine # pylint: disable=unused-argument def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the template sensors.""" sensors = [] for device, device_config in config[CONF_SENSORS].items(): state_template = device_config[CONF_VALUE_TEMPLATE] icon_template = device_config.get(CONF_ICON_TEMPLATE) entity_picture_template = device_config.get( CONF_ENTITY_PICTURE_TEMPLATE) friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
_LOGGER = logging.getLogger(__name__) _RESOURCE = 'http://apilayer.net/api/live' CONF_ATTRIBUTION = "Data provided by currencylayer.com" DEFAULT_BASE = 'USD' DEFAULT_NAME = 'CurrencyLayer Sensor' ICON = 'mdi:currency' SCAN_INTERVAL = timedelta(hours=2) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_QUOTE): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_BASE, default=DEFAULT_BASE): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Currencylayer sensor.""" base = config.get(CONF_BASE) api_key = config.get(CONF_API_KEY) parameters = { 'source': base, 'access_key': api_key, 'format': 1, } rest = CurrencylayerData(_RESOURCE, parameters)
SENSOR_TYPES = { 'max_breaking_swell': ['Max'], 'min_breaking_swell': ['Min'], 'swell_forecast': ['Forecast'], } UNITS = ['eu', 'uk', 'us'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_MONITORED_CONDITIONS): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_SPOT_ID): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_HOURS, default=None): vol.All(cv.ensure_list, [vol.In(HOURS)]), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_UNITS): vol.In(UNITS), }) # Return cached results if last scan was less then this time ago. MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=30) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Magicseaweed sensor.""" name = config.get(CONF_NAME) spot_id = config[CONF_SPOT_ID]
CONF_PAYLOAD, CONF_NAME, CONF_VALUE_TEMPLATE, CONF_METHOD, CONF_RESOURCE, CONF_UNIT_OF_MEASUREMENT, STATE_UNKNOWN, CONF_VERIFY_SSL) from homeassistant.helpers.entity import Entity import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DEFAULT_METHOD = 'GET' DEFAULT_NAME = 'REST Sensor' DEFAULT_VERIFY_SSL = True PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_RESOURCE): cv.url, vol.Optional(CONF_METHOD, default=DEFAULT_METHOD): vol.In(['POST', 'GET']), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PAYLOAD): cv.string, vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean, }) # pylint: disable=unused-variable def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the RESTful sensor.""" name = config.get(CONF_NAME) resource = config.get(CONF_RESOURCE) method = config.get(CONF_METHOD) payload = config.get(CONF_PAYLOAD) verify_ssl = config.get(CONF_VERIFY_SSL) unit = config.get(CONF_UNIT_OF_MEASUREMENT)
["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(hass, 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:
def validate_station(station): """Check that the station ID is well-formed.""" if station is None: return station = station.replace('.shtml', '') if not re.fullmatch(r'ID[A-Z]\d\d\d\d\d\.\d\d\d\d\d', station): raise vol.error.Invalid('Malformed station ID') return station PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Inclusive(CONF_ZONE_ID, 'Deprecated partial station ID'): cv.string, vol.Inclusive(CONF_WMO_ID, 'Deprecated partial station ID'): cv.string, vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_STATION): validate_station, vol.Required(CONF_MONITORED_CONDITIONS, default=[]): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the BOM sensor.""" station = config.get(CONF_STATION) zone_id, wmo_id = config.get(CONF_ZONE_ID), config.get(CONF_WMO_ID) if station is not None: if zone_id and wmo_id: _LOGGER.warning( "Using config %s, not %s and %s for BOM sensor", CONF_STATION, CONF_ZONE_ID, CONF_WMO_ID)
from homeassistant.helpers.entity import Entity import homeassistant.util.dt as dt_util REQUIREMENTS = ['schiene==0.18'] _LOGGER = logging.getLogger(__name__) CONF_DESTINATION = 'to' CONF_START = 'from' ICON = 'mdi:train' MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=120) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DESTINATION): cv.string, vol.Required(CONF_START): cv.string, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Deutsche Bahn Sensor.""" start = config.get(CONF_START) destination = config.get(CONF_DESTINATION) add_devices([DeutscheBahnSensor(start, destination)]) class DeutscheBahnSensor(Entity): """Implementation of a Deutsche Bahn sensor.""" def __init__(self, start, goal): """Initialize the sensor."""
DEPENDENCIES = ['arlo'] # sensor_type [ description, unit, icon ] SENSOR_TYPES = { 'last_capture': ['Last', None, 'run-fast'], 'total_cameras': ['Arlo Cameras', None, 'video'], 'captured_today': ['Captured Today', None, 'file-video'], 'battery_level': ['Battery Level', '%', 'battery-50'], 'signal_strength': ['Signal Strength', None, 'signal'], 'temperature': ['Temperature', TEMP_CELSIUS, 'thermometer'], 'humidity': ['Humidity', '%', 'water-percent'], 'air_quality': ['Air Quality', 'ppm', 'biohazard'] } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_MONITORED_CONDITIONS, default=list(SENSOR_TYPES)): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up an Arlo IP sensor.""" arlo = hass.data.get(DATA_ARLO) if not arlo: return sensors = [] for sensor_type in config.get(CONF_MONITORED_CONDITIONS): if sensor_type == 'total_cameras': sensors.append(ArloSensor( SENSOR_TYPES[sensor_type][0], arlo, sensor_type)) else:
CONF_FOLDER_PATHS = 'folder' CONF_FILTER = 'filter' CONF_NAME = 'name' CONF_SORT = 'sort' DEFAULT_FILTER = '*' DEFAULT_SORT = 'date' DOMAIN = 'files' SCAN_INTERVAL = timedelta(minutes=1) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_FOLDER_PATHS): cv.isdir, vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_FILTER, default=DEFAULT_FILTER): cv.string, vol.Optional(CONF_SORT, default=DEFAULT_SORT): cv.string, }) def get_files_list(folder_path, filter_term, sort): """Return the list of files, applying filter.""" query = folder_path + filter_term """files_list = glob.glob(query)""" if sort == 'name': files_list = sorted(glob.glob(query)) elif sort == 'size': files_list = sorted(glob.glob(query), key=os.path.getsize) else:
'°C', '°F', '°C', '°C', '°C', 'mdi:thermometer', ['currently', 'hourly', 'daily']], 'temperature_min': ['Daily Low Temperature', '°C', '°F', '°C', '°C', '°C', 'mdi:thermometer', ['currently', 'hourly', 'daily']], 'precip_intensity_max': ['Daily Max Precip Intensity', 'mm', 'in', 'mm', 'mm', 'mm', 'mdi:thermometer', ['currently', 'hourly', 'daily']], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_MONITORED_CONDITIONS): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), vol.Required(CONF_API_KEY): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_UNITS): vol.In(['auto', 'si', 'us', 'ca', 'uk', 'uk2']), vol.Optional(CONF_UPDATE_INTERVAL, default=timedelta(seconds=120)): ( vol.All(cv.time_period, cv.positive_timedelta)), vol.Optional(CONF_FORECAST): vol.All(cv.ensure_list, [vol.Range(min=1, max=7)]), }) def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Dark Sky sensor.""" # Validate the configuration if None in (hass.config.latitude, hass.config.longitude): _LOGGER.error("Latitude or longitude not set in Home Assistant config") return False if CONF_UNITS in config:
_LOGGER = logging.getLogger(__name__) SENSOR_SCHEMA = vol.Schema({ vol.Required(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_ICON_TEMPLATE): cv.template, vol.Optional(CONF_ENTITY_PICTURE_TEMPLATE): cv.template, vol.Optional(CONF_FRIENDLY_NAME_TEMPLATE): cv.template, vol.Optional(ATTR_FRIENDLY_NAME): cv.string, vol.Optional(ATTR_UNIT_OF_MEASUREMENT): cv.string, vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, vol.Optional(ATTR_ENTITY_ID): cv.entity_ids }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_SENSORS): cv.schema_with_slug_keys(SENSOR_SCHEMA), }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the template sensors.""" sensors = [] for device, device_config in config[CONF_SENSORS].items(): state_template = device_config[CONF_VALUE_TEMPLATE] icon_template = device_config.get(CONF_ICON_TEMPLATE) entity_picture_template = device_config.get( CONF_ENTITY_PICTURE_TEMPLATE)
_LOGGER = logging.getLogger(__name__) CONF_BEACONS = 'beacons' CONF_BT_DEVICE_ID = 'bt_device_id' CONF_INSTANCE = 'instance' CONF_NAMESPACE = 'namespace' BEACON_SCHEMA = vol.Schema({ vol.Required(CONF_NAMESPACE): cv.string, vol.Required(CONF_INSTANCE): cv.string, vol.Optional(CONF_NAME): cv.string }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_BT_DEVICE_ID, default=0): cv.positive_int, vol.Required(CONF_BEACONS): vol.Schema({cv.string: BEACON_SCHEMA}), }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Validate configuration, create devices and start monitoring thread.""" bt_device_id = config.get("bt_device_id") beacons = config.get("beacons") devices = [] for dev_name, properties in beacons.items(): namespace = get_from_conf(properties, "namespace", 20) instance = get_from_conf(properties, "instance", 12) name = properties.get(CONF_NAME, dev_name)
STOP_NAME = "stop_name" USER_AGENT = "Home Assistant" ATTRIBUTION = "Data provided by maps.yandex.ru" CONF_STOP_ID = "stop_id" CONF_ROUTE = "routes" DEFAULT_NAME = "Yandex Transport" ICON = "mdi:bus" SCAN_INTERVAL = timedelta(minutes=1) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_STOP_ID): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_ROUTE, default=[]): vol.All(cv.ensure_list, [cv.string]), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Yandex transport sensor.""" stop_id = config[CONF_STOP_ID] name = config[CONF_NAME] routes = config[CONF_ROUTE] data = YandexMapsRequester(user_agent=USER_AGENT) add_entities([DiscoverMoscowYandexTransport(data, stop_id, routes, name)], True)
EVENT_OPENSKY_ENTRY = '{}_entry'.format(DOMAIN) EVENT_OPENSKY_EXIT = '{}_exit'.format(DOMAIN) SCAN_INTERVAL = timedelta(seconds=12) # opensky public limit is 10 seconds OPENSKY_ATTRIBUTION = "Information provided by the OpenSky Network "\ "(https://opensky-network.org)" OPENSKY_API_URL = 'https://opensky-network.org/api/states/all' OPENSKY_API_FIELDS = [ 'icao24', ATTR_CALLSIGN, 'origin_country', 'time_position', 'time_velocity', ATTR_LONGITUDE, ATTR_LATITUDE, 'altitude', ATTR_ON_GROUND, 'velocity', 'heading', 'vertical_rate', 'sensors'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_RADIUS): vol.Coerce(float), vol.Optional(CONF_NAME): cv.string, vol.Inclusive(CONF_LATITUDE, 'coordinates'): cv.latitude, vol.Inclusive(CONF_LONGITUDE, 'coordinates'): cv.longitude }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Open Sky platform.""" latitude = config.get(CONF_LATITUDE, hass.config.latitude) longitude = config.get(CONF_LONGITUDE, hass.config.longitude) add_devices([OpenSkySensor( hass, config.get(CONF_NAME, DOMAIN), latitude, longitude, config.get(CONF_RADIUS))], True) class OpenSkySensor(Entity): """Open Sky Network Sensor."""
if isinstance(val, str): val = template.Template(val) entity_cfg[to_key] = val if CONF_NAME not in entity_cfg: entity_cfg[CONF_NAME] = template.Template(object_id) sensors.append(entity_cfg) return sensors PLATFORM_SCHEMA = vol.All( PLATFORM_SCHEMA.extend({ vol.Optional(CONF_TRIGGER): cv.match_all, # to raise custom warning vol.Required(CONF_SENSORS): cv.schema_with_slug_keys(LEGACY_SENSOR_SCHEMA), }), extra_validation_checks, ) @callback def _async_create_template_tracking_entities(async_add_entities, hass, definitions: list[dict], unique_id_prefix: str | None): """Create the template sensors.""" sensors = [] for entity_conf in definitions: # Still available on legacy
ATTR_LOCAL_IP: [ ['wan', 'localIpAddress'], None, 'mdi:access-point-network' ], ATTR_STATUS: [ ['wan', 'online'], None, 'mdi:google' ] } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_MONITORED_CONDITIONS, default=list(MONITORED_CONDITIONS)): vol.All(cv.ensure_list, [vol.In(MONITORED_CONDITIONS)]), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Google Wifi sensor.""" name = config.get(CONF_NAME) host = config.get(CONF_HOST) conditions = config.get(CONF_MONITORED_CONDITIONS) api = GoogleWifiAPI(host, conditions) dev = [] for condition in conditions: dev.append(GoogleWifiSensor(api, name, condition))
DEFAULT_NAME = "Tautulli" DEFAULT_PORT = "8181" DEFAULT_PATH = "" DEFAULT_SSL = False DEFAULT_VERIFY_SSL = True PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_MONITORED_CONDITIONS): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_MONITORED_USERS): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.string, vol.Optional(CONF_PATH, default=DEFAULT_PATH): cv.string, vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean, vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean, }) async def async_setup_platform( hass: HomeAssistant, config: ConfigType, async_add_entities: AddEntitiesCallback,
DEVICE_DEFAULT_NAME = 'Broadlink sensor' DEFAULT_TIMEOUT = 10 SENSOR_TYPES = { 'temperature': ['Temperature', TEMP_CELSIUS], 'air_quality': ['Air Quality', ' '], 'humidity': ['Humidity', '%'], 'light': ['Light', ' '], 'noise': ['Noise', ' '], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEVICE_DEFAULT_NAME): vol.Coerce(str), vol.Optional(CONF_MONITORED_CONDITIONS, default=[]): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), vol.Optional(CONF_UPDATE_INTERVAL, default=timedelta(seconds=300)): ( vol.All(cv.time_period, cv.positive_timedelta)), vol.Required(CONF_HOST): cv.string, vol.Required(CONF_MAC): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Broadlink device sensors.""" host = config.get(CONF_HOST) mac = config.get(CONF_MAC).encode().replace(b':', b'') mac_addr = binascii.unhexlify(mac) name = config.get(CONF_NAME) timeout = config.get(CONF_TIMEOUT) update_interval = config.get(CONF_UPDATE_INTERVAL)
ATTR_NEXT_DEPARTURE = "next_departure" ATTRIBUTION = "Data retrieved from telematics.oasa.gr" CONF_STOP_ID = "stop_id" CONF_ROUTE_ID = "route_id" DEFAULT_NAME = "OASA Telematics" ICON = "mdi:bus" SCAN_INTERVAL = timedelta(seconds=60) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_STOP_ID): cv.string, vol.Required(CONF_ROUTE_ID): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform( hass: HomeAssistant, config: ConfigType, add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Set up the OASA Telematics sensor.""" name = config[CONF_NAME] stop_id = config[CONF_STOP_ID] route_id = config.get(CONF_ROUTE_ID)
'symbol_1d': ['Symbol 1d', None, None], 'symbol_2d': ['Symbol 2d', None, None], 'symbol_3d': ['Symbol 3d', None, None], 'symbol_4d': ['Symbol 4d', None, None], 'symbol_5d': ['Symbol 5d', None, None], } CONF_TIMEFRAME = 'timeframe' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_MONITORED_CONDITIONS, default=['symbol', 'temperature']): vol.All( cv.ensure_list, vol.Length(min=1), [vol.In(SENSOR_TYPES.keys())]), vol.Inclusive(CONF_LATITUDE, 'coordinates', 'Latitude and longitude must exist together'): cv.latitude, vol.Inclusive(CONF_LONGITUDE, 'coordinates', 'Latitude and longitude must exist together'): cv.longitude, vol.Optional(CONF_TIMEFRAME, default=60): vol.All(vol.Coerce(int), vol.Range(min=5, max=120)), vol.Optional(CONF_NAME, default='br'): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Create the buienradar sensor.""" from .weather import DEFAULT_TIMEFRAME latitude = config.get(CONF_LATITUDE, hass.config.latitude) longitude = config.get(CONF_LONGITUDE, hass.config.longitude)
ATTR_ASSETS = 'assets' ATTR_LIABILITIES = 'liabilities' ATTR_INVESTMENTS = 'investments' ATTR_MORTGAGES = 'mortgages' ATTR_CASH = 'cash' ATTR_OTHER_ASSETS = 'other_assets' ATTR_OTHER_LIABILITIES = 'other_liabilities' ATTR_CREDIT = 'credit_cards' ATTR_LOANS = 'loans' SCAN_INTERVAL = timedelta(minutes=30) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_EMAIL): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_UNIT_OF_MEASUREMENT, default='USD'): cv.string, }) _CONFIGURING = {} _LOGGER = logging.getLogger(__name__) _CACHE = {} def request_app_setup(hass, config, pc, add_devices, discovery_info=None): """Request configuration steps from the user.""" from personalcapital import PersonalCapital, RequireTwoFactorException, TwoFactorVerificationModeEnum configurator = hass.components.configurator
VALUE_CALL = 'dialing' VALUE_CONNECT = 'talking' VALUE_DEFAULT = 'idle' VALUE_DISCONNECT = 'idle' VALUE_RING = 'ringing' # Return cached results if phonebook was downloaded less then this time ago. MIN_TIME_PHONEBOOK_UPDATE = datetime.timedelta(hours=6) SCAN_INTERVAL = datetime.timedelta(hours=3) 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, vol.Optional(CONF_PASSWORD, default='admin'): cv.string, vol.Optional(CONF_USERNAME, default=''): cv.string, vol.Optional(CONF_PHONEBOOK, default=0): cv.positive_int, vol.Optional(CONF_PREFIXES, default=[]): vol.All(cv.ensure_list, [cv.string]) }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up Fritz!Box call monitor sensor platform.""" name = config.get(CONF_NAME) host = config.get(CONF_HOST) port = config.get(CONF_PORT) username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) phonebook_id = config.get('phonebook') prefixes = config.get('prefixes')
KEY_DEVICE_ID, KEY_DEVICE_LOCATION, KEY_DEVICE_LOCATION_NAME, KEY_DEVICE_LOCATION_TIMEZONE, KEY_DEVICE_TYPE, ) _LOGGER = logging.getLogger(__name__) MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=15) SCAN_INTERVAL = timedelta(minutes=1) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_CLIENT_ID): cv.string, vol.Required(CONF_CLIENT_SECRET): cv.string, vol.Optional(CONF_NAME): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Import the platform into a config entry.""" hass.async_create_task( hass.config_entries.flow.async_init(DOMAIN, context={"source": SOURCE_IMPORT}, data=config))
import voluptuous as vol from homeassistant.components.sensor import PLATFORM_SCHEMA from homeassistant.const import (CONF_NAME, CONF_ID) from homeassistant.helpers.entity import Entity import homeassistant.helpers.config_validation as cv from homeassistant.components import enocean _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = 'EnOcean sensor' DEPENDENCIES = ['enocean'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ID): vol.All(cv.ensure_list, [vol.Coerce(int)]), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up an EnOcean sensor device.""" dev_id = config.get(CONF_ID) devname = config.get(CONF_NAME) add_devices([EnOceanSensor(dev_id, devname)]) class EnOceanSensor(enocean.EnOceanDevice, Entity): """Representation of an EnOcean sensor device such as a power meter.""" def __init__(self, dev_id, devname):
'first_stars': ['T\'set Hakochavim', 'mdi:weather-night'], } CONF_DIASPORA = 'diaspora' CONF_LANGUAGE = 'language' CONF_SENSORS = 'sensors' DEFAULT_NAME = 'Jewish Calendar' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_DIASPORA, default=False): cv.boolean, vol.Optional(CONF_LATITUDE): cv.latitude, vol.Optional(CONF_LONGITUDE): cv.longitude, vol.Optional(CONF_LANGUAGE, default='english'): vol.In(['hebrew', 'english']), vol.Optional(CONF_SENSORS, default=['date']): vol.All(cv.ensure_list, vol.Length(min=1), [vol.In(SENSOR_TYPES)]), }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the Jewish calendar sensor platform.""" language = config.get(CONF_LANGUAGE) name = config.get(CONF_NAME)
SCAN_INTERVAL = timedelta(seconds=1200) # Sensor types are defined like: Name, units, icon SENSOR_TYPES = { 'temperature': ['Temperature', '°C', 'mdi:thermometer'], 'light': ['Light intensity', 'lx', 'mdi:white-balance-sunny'], 'moisture': ['Moisture', '%', 'mdi:water-percent'], 'conductivity': ['Conductivity', 'µS/cm', 'mdi:flash-circle'], 'battery': ['Battery', '%', 'mdi:battery-charging'], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_MAC): cv.string, 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, vol.Optional(CONF_MEDIAN, default=DEFAULT_MEDIAN): cv.positive_int, vol.Optional(CONF_FORCE_UPDATE, default=DEFAULT_FORCE_UPDATE): cv.boolean, vol.Optional(CONF_ADAPTER, default=DEFAULT_ADAPTER): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the MiFlora sensor.""" from miflora import miflora_poller try: import bluepy.btle # noqa: F401 pylint: disable=unused-import from btlewrap import BluepyBackend backend = BluepyBackend except ImportError:
SENSOR_TYPES = { 'weather': ['Condition', None], 'temperature': ['Temperature', None], 'wind_speed': ['Wind speed', 'm/s'], 'humidity': ['Humidity', '%'], 'pressure': ['Pressure', 'mbar'], 'clouds': ['Cloud coverage', '%'], 'rain': ['Rain', 'mm'], 'snow': ['Snow', 'mm'] } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Optional(CONF_MONITORED_CONDITIONS, default=[]): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_FORECAST, default=False): cv.boolean }) def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the OpenWeatherMap sensor.""" if None in (hass.config.latitude, hass.config.longitude): _LOGGER.error("Latitude or longitude not set in Home Assistant config") return False from pyowm import OWM SENSOR_TYPES['temperature'][1] = hass.config.units.temperature_unit
'accelerometer_y': ['accelerometer_y', 'G', 'mdi:earth'], 'accelerometer_z': ['accelerometer_z', 'G', 'mdi:earth'], 'magnetometer_x': ['magnetometer_x', ' ', 'mdi:magnet'], 'magnetometer_y': ['magnetometer_y', ' ', 'mdi:magnet'], 'magnetometer_z': ['magnetometer_z', ' ', 'mdi:magnet'], 'temperature': ['temperature', TEMP_CELSIUS, 'mdi:thermometer'], 'pressure': ['pressure', 'hPa', 'mdi:gauge'], 'voltage_0': ['voltage_0', 'V', 'mdi:flash'], 'voltage_1': ['voltage_1', 'V', 'mdi:flash'], 'voltage_2': ['voltage_2', 'V', 'mdi:flash'], 'voltage_3': ['voltage_3', 'V', 'mdi:flash'], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DISPLAY_OPTIONS, default=SENSOR_TYPES): [vol.In(SENSOR_TYPES)], vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_USE_LEDS, default=False): cv.boolean }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Sense HAT sensor platform.""" data = EnvirophatData(config.get(CONF_USE_LEDS)) dev = [] for variable in config[CONF_DISPLAY_OPTIONS]: dev.append(EnvirophatSensor(data, variable)) add_devices(dev, True)
} # Metric units SENSOR_UNITS_METRIC = { "Temperature": TEMP_CELSIUS, "Humidity": PERCENTAGE, "Pressure": PRESSURE_MBAR, "Luminance": f"cd/{AREA_SQUARE_METERS}", "Voltage": "mV", } # Which sensors to format numerically FORMAT_NUMBERS = ["Temperature", "Pressure", "Voltage"] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_MONITORED_CONDITIONS, default=SENSOR_TYPES): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]) }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the available BloomSky weather sensors.""" # Default needed in case of discovery if discovery_info is not None: return sensors = config[CONF_MONITORED_CONDITIONS] bloomsky = hass.data[DOMAIN] for device in bloomsky.devices.values(): for variable in sensors: add_entities([BloomSkySensor(bloomsky, device, variable)], True)
UPDATE_DELAY = timedelta(hours=12) SCAN_INTERVAL = timedelta(hours=12) # Supported sensor types: # Key: [json_key, name, icon] SENSOR_TYPES = { 'bio': ['gft', 'Biowaste', 'mdi:recycle'], 'paper': ['papier', 'Paper', 'mdi:recycle'], 'plastic': ['plasticplus', 'PET', 'mdi:recycle'], 'residual': ['rest', 'Residual', 'mdi:recycle']} PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ZIP_CODE): cv.string, vol.Required(CONF_HOUSE_NUMBER): cv.string, vol.Optional(CONF_HOUSE_NUMBER_SUFFIX, default=''): cv.string, vol.Optional(CONF_NAME, default='Rova'): cv.string, vol.Optional(CONF_MONITORED_CONDITIONS, default=['bio']): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]) }) _LOGGER = logging.getLogger(__name__) def setup_platform(hass, config, add_entities, discovery_info=None): """Create the Rova data service and sensors.""" from rova.rova import Rova from requests.exceptions import HTTPError, ConnectTimeout zip_code = config[CONF_ZIP_CODE] house_number = config[CONF_HOUSE_NUMBER] house_number_suffix = config[CONF_HOUSE_NUMBER_SUFFIX]
import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity import Entity REQUIREMENTS = ['py-cpuinfo==0.2.7'] _LOGGER = logging.getLogger(__name__) ATTR_BRAND = 'Brand' ATTR_HZ = 'GHz Advertised' ATTR_VENDOR = 'Vendor ID' DEFAULT_NAME = 'CPU speed' ICON = 'mdi:pulse' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) # pylint: disable=unused-variable def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the CPU speed sensor.""" name = config.get(CONF_NAME) add_devices([CpuSpeedSensor(name)]) class CpuSpeedSensor(Entity): """Representation of a CPU sensor.""" def __init__(self, name): """Initialize the sensor."""
DEFAULT_DSMR_VERSION = '2.2' DEFAULT_PORT = '/dev/ttyUSB0' DOMAIN = 'dsmr' ICON_GAS = 'mdi:fire' ICON_POWER = 'mdi:flash' # Smart meter sends telegram every 10 seconds MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=10) RECONNECT_INTERVAL = 5 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.string, vol.Optional(CONF_HOST): cv.string, vol.Optional(CONF_DSMR_VERSION, default=DEFAULT_DSMR_VERSION): vol.All( cv.string, vol.In(['5', '4', '2.2'])), vol.Optional(CONF_RECONNECT_INTERVAL, default=30): int, }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the DSMR sensor.""" # Suppress logging logging.getLogger('dsmr_parser').setLevel(logging.ERROR) from dsmr_parser import obis_references as obis_ref from dsmr_parser.clients.protocol import ( create_dsmr_reader, create_tcp_dsmr_reader) import serial
CONF_APP_ID = 'app_id' CONF_APP_CODE = 'app_code' CONF_MIN_DISTANCE = 'minimum_distance' DEFAULT_NAME = 'Here Travel Time' TRACKABLE_DOMAINS = ['device_tracker', 'sensor', 'zone'] DATA_KEY = 'here_travel_time' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_APP_ID): cv.string, vol.Required(CONF_APP_CODE): cv.string, vol.Required(CONF_DESTINATION): cv.string, vol.Required(CONF_ORIGIN): cv.string, vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_MIN_DISTANCE, default=100): cv.positive_int, }) def setup_platform(hass, config, add_devices): """Setup """ def run_setup(event): if DATA_KEY not in hass.data: hass.data[DATA_KEY] = [] hass.services.register(DOMAIN, 'here_travel_sensor_update', update)
SENSOR_TYPES = { 'weather_current': ['Current', None], 'weather': ['Condition', None], 'temperature': ['Temperature', "temperature"], 'temp_min': ['Temperature min', "temperature"], 'temp_max': ['Temperature max', "temperature"], 'wind_speed': ['Wind speed', "speed"], 'humidity': ['Humidity', "%"], 'pressure': ['Pressure', "pressure"], 'visibility': ['Visibility', "distance"], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_WOEID, default=None): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_FORECAST, default=0): vol.All(vol.Coerce(int), vol.Range(min=0, max=5)), vol.Required(CONF_MONITORED_CONDITIONS, default=[]): [vol.In(SENSOR_TYPES)], }) def setup_platform(hass, config, add_devices, discovery_info=None): """Setnup the Yahoo! weather sensor.""" from yahooweather import get_woeid, UNIT_C, UNIT_F unit = hass.config.units.temperature_unit woeid = config.get(CONF_WOEID) forecast = config.get(CONF_FORECAST) name = config.get(CONF_NAME) yunit = UNIT_C if unit == TEMP_CELSIUS else UNIT_F
ATTR_CANCELED = "canceled" ATTR_DELAY_TIME = "number_of_minutes_delayed" ATTR_PLANNED_TIME = "planned_time" #When it planned to arrive if no delays occure ATTR_ESTIMATED_TIME = "estimated_time" #When its estimated to arrive when delays occure ATTR_ACTUAL_TIME = "actual_time" #When it did arrive ATTR_OTHER_INFORMATION = "other_information" ATTR_DEVIATIONS = "deviations" ICON = "mdi:train" SCAN_INTERVAL = timedelta(minutes=5) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_TRAINS): [{ vol.Required(CONF_NAME): cv.string, vol.Required(CONF_TO): cv.string, vol.Required(CONF_FROM): cv.string, vol.Optional(CONF_TIME): cv.time}] }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Setup the departure sensor.""" _LOGGER.debug("start async_setup_platform") from pytrafikverket import TrafikverketTrain httpsession = async_get_clientsession(hass) train_api = TrafikverketTrain(httpsession, config.get(CONF_API_KEY)) sensors = [] for train in config.get(CONF_TRAINS): from_sig = yield from train_api.async_get_train_station(train.get(CONF_FROM)) to_sig = yield from train_api.async_get_train_station(train.get(CONF_TO))
'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(hass, config, add_entities, discovery_info=None): """Set up the Bitcoin sensors.""" from blockchain import exchangerates currency = config.get(CONF_CURRENCY) if currency not in exchangerates.get_ticker(): _LOGGER.warning("Currency %s is not available. Using USD", currency) currency = DEFAULT_CURRENCY data = BitcoinData()
CONF_VALUE_ON = "value_on" DEFAULT_BUFFER_SIZE = 1024 DEFAULT_NAME = "TCP Sensor" DEFAULT_TIMEOUT = 10 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PORT): cv.port, vol.Required(CONF_PAYLOAD): cv.string, vol.Optional(CONF_BUFFER_SIZE, default=DEFAULT_BUFFER_SIZE): cv.positive_int, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string, vol.Optional(CONF_VALUE_ON): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the TCP Sensor.""" add_entities([TcpSensor(hass, config)])
_LOGGER = logging.getLogger(__name__) ATTRIBUTION = "Data provided by Shodan" CONF_QUERY = 'query' DEFAULT_NAME = 'Shodan Sensor' ICON = 'mdi:tooltip-text' SCAN_INTERVAL = timedelta(minutes=15) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_QUERY): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Shodan sensor.""" import shodan api_key = config.get(CONF_API_KEY) name = config.get(CONF_NAME) query = config.get(CONF_QUERY) data = ShodanData(shodan.Shodan(api_key), query) try: data.update()
CONF_PASSWORD) import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_SERVER = "server" 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, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the IMAP platform.""" sensor = ImapSensor(config.get(CONF_NAME, None), config.get(CONF_USERNAME), config.get(CONF_PASSWORD), config.get(CONF_SERVER), config.get(CONF_PORT)) if sensor.connection: add_devices([sensor])
import voluptuous as vol from homeassistant.components.sensor import PLATFORM_SCHEMA from homeassistant.const import CONF_NAME, DEVICE_DEFAULT_NAME, TEMP_FAHRENHEIT from homeassistant.helpers.entity import Entity _LOGGER = logging.getLogger(__name__) REQUIREMENTS = ['temperusb==1.5.1'] CONF_SCALE = 'scale' CONF_OFFSET = 'offset' 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) }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Temper sensors.""" from temperusb.temper import TemperHandler temp_unit = hass.config.units.temperature_unit name = config.get(CONF_NAME) scaling = { 'scale': config.get(CONF_SCALE), 'offset': config.get(CONF_OFFSET) }
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(hass, config, add_entities, discovery_info=None): """Set up the GeoRSS component.""" latitude = config.get(CONF_LATITUDE, hass.config.latitude) longitude = config.get(CONF_LONGITUDE, hass.config.longitude) url = config.get(CONF_URL)
CONF_HUB, DEFAULT_HUB, DOMAIN as MODBUS_DOMAIN) from homeassistant.const import CONF_NAME, CONF_SLAVE from homeassistant.components.binary_sensor import BinarySensorDevice from homeassistant.helpers import config_validation as cv from homeassistant.components.sensor import PLATFORM_SCHEMA _LOGGER = logging.getLogger(__name__) DEPENDENCIES = ['modbus'] CONF_COIL = 'coil' CONF_COILS = 'coils' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_COILS): [{ vol.Optional(CONF_HUB, default=DEFAULT_HUB): cv.string, vol.Required(CONF_COIL): cv.positive_int, vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_SLAVE): cv.positive_int, }] }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Modbus binary sensors.""" sensors = [] for coil in config.get(CONF_COILS): hub = hass.data[MODBUS_DOMAIN][coil.get(CONF_HUB)] sensors.append(ModbusCoilSensor( hub, coil.get(CONF_NAME), coil.get(CONF_SLAVE), coil.get(CONF_COIL))) add_entities(sensors)
from homeassistant.util import slugify from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.entity import Entity REQUIREMENTS = ['beautifulsoup4==4.7.1'] # TODO: Remove this when it can be loaded with manifestfile BASEURL = 'https://www.oslo.kommune.no/avfall-og-gjenvinning/avfallshenting/' ATTR_PICKUP_DATE = 'pickup_date' ATTR_PICKUP_FREQUENCY = 'pickup_frequency' ATTR_ADDRESS = 'address' _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required('address'): cv.string, vol.Optional('street'): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): ws = OsloWasteScraper(hass, config) await ws.async_update() waste_types = await ws.waste_types() for wt in waste_types: _LOGGER.info("Adding sensor for %s (%s)", config['address'], wt) async_add_entities([OsloWasteSensor(hass, ws, wt)], True) class OsloWasteScraper: def __init__(self, hass, config):
_LOGGER = logging.getLogger(__name__) CONF_CHANNEL_ID = 'channel_id' DEFAULT_NAME = 'ELIQ Online' ICON = 'mdi:gauge' SCAN_INTERVAL = timedelta(seconds=60) UNIT_OF_MEASUREMENT = 'W' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ACCESS_TOKEN): cv.string, vol.Required(CONF_CHANNEL_ID): cv.positive_int, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the ELIQ Online sensor.""" import eliqonline access_token = config.get(CONF_ACCESS_TOKEN) name = config.get(CONF_NAME, DEFAULT_NAME) channel_id = config.get(CONF_CHANNEL_ID) session = async_get_clientsession(hass) api = eliqonline.API(session=session,
'weather': ['Condition', None], 'temperature': ['Temperature', None], 'wind_speed': ['Wind speed', 'm/s'], 'wind_bearing': ['Wind bearing', '°'], 'humidity': ['Humidity', '%'], 'pressure': ['Pressure', 'mbar'], 'clouds': ['Cloud coverage', '%'], 'rain': ['Rain', 'mm'], 'snow': ['Snow', 'mm'], 'weather_code': ['Weather code', None], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Optional(CONF_MONITORED_CONDITIONS, default=[]): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_FORECAST, default=False): cv.boolean, vol.Optional(CONF_LANGUAGE): cv.string, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the OpenWeatherMap sensor.""" from pyowm import OWM if None in (hass.config.latitude, hass.config.longitude): _LOGGER.error("Latitude or longitude not set in Home Assistant config") return SENSOR_TYPES['temperature'][1] = hass.config.units.temperature_unit
from homeassistant.helpers import template from homeassistant.exceptions import TemplateError from homeassistant.const import ( CONF_NAME, CONF_VALUE_TEMPLATE, CONF_UNIT_OF_MEASUREMENT, CONF_COMMAND, STATE_UNKNOWN) from homeassistant.helpers.entity import Entity _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = 'Command Sensor' SCAN_INTERVAL = timedelta(seconds=60) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_COMMAND): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Command Sensor.""" name = config.get(CONF_NAME) command = config.get(CONF_COMMAND) unit = config.get(CONF_UNIT_OF_MEASUREMENT) value_template = config.get(CONF_VALUE_TEMPLATE) if value_template is not None: value_template.hass = hass data = CommandSensorData(hass, command) add_devices([CommandSensor(hass, data, name, unit, value_template)], True)
CONF_SERVER_ID = 'server_id' CONF_MANUAL = 'manual' SENSOR_TYPES = { 'ping': ['Ping', 'ms'], 'download': ['Download', 'Mbit/s'], 'upload': ['Upload', 'Mbit/s'], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_MONITORED_CONDITIONS): vol.All(cv.ensure_list, [vol.In(list(SENSOR_TYPES))]), vol.Optional(CONF_SERVER_ID): cv.positive_int, vol.Optional(CONF_SECOND, default=[0]): vol.All(cv.ensure_list, [vol.All(vol.Coerce(int), vol.Range(0, 59))]), vol.Optional(CONF_MINUTE, default=[0]): vol.All(cv.ensure_list, [vol.All(vol.Coerce(int), vol.Range(0, 59))]), vol.Optional(CONF_HOUR): vol.All(cv.ensure_list, [vol.All(vol.Coerce(int), vol.Range(0, 23))]), vol.Optional(CONF_DAY): vol.All(cv.ensure_list, [vol.All(vol.Coerce(int), vol.Range(1, 31))]), vol.Optional(CONF_MANUAL, default=False): cv.boolean, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Speedtest sensor.""" data = SpeedtestData(hass, config) dev = [] for sensor in config[CONF_MONITORED_CONDITIONS]: if sensor not in SENSOR_TYPES: _LOGGER.error("Sensor type: %s does not exist", sensor)