PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_MAX_ACCURACY, default=0): vol.All( vol.Coerce(int), vol.Range(min=0) ), vol.Optional(CONF_SKIP_ACCURACY_ON, default=[]): vol.All( cv.ensure_list, [cv.string] ), vol.Optional(CONF_MONITORED_CONDITIONS, default=[]): vol.All( cv.ensure_list, [cv.string] ), vol.Optional(CONF_EVENT, default=[]): vol.All( cv.ensure_list, [ vol.Any( EVENT_DEVICE_MOVING, EVENT_COMMAND_RESULT, EVENT_DEVICE_FUEL_DROP, EVENT_GEOFENCE_ENTER, EVENT_DEVICE_OFFLINE, EVENT_GEOFENCE_EXIT, EVENT_DEVICE_OVERSPEED, EVENT_DEVICE_ONLINE, EVENT_DEVICE_STOPPED, EVENT_MAINTENANCE, EVENT_ALARM, EVENT_TEXT_MESSAGE, EVENT_DEVICE_UNKNOWN, EVENT_ALL_EVENTS, ) ], ), } )
CONF_PROTOCOL = 'protocol' CONF_MODE = 'mode' DEFAULT_SSH_PORT = 22 CONF_SSH_KEY = 'ssh_key' CONF_PUB_KEY = 'pub_key' SECRET_GROUP = 'Password or SSH Key' PLATFORM_SCHEMA = vol.All( cv.has_at_least_one_key(CONF_PASSWORD, CONF_PUB_KEY, CONF_SSH_KEY), PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_PROTOCOL, default='ssh'): vol.In(['ssh', 'telnet']), vol.Optional(CONF_MODE, default='router'): vol.In(['router', 'ap']), vol.Optional(CONF_PORT, default=DEFAULT_SSH_PORT): cv.port, vol.Exclusive(CONF_PASSWORD, SECRET_GROUP): cv.string, vol.Exclusive(CONF_SSH_KEY, SECRET_GROUP): cv.isfile, vol.Exclusive(CONF_PUB_KEY, SECRET_GROUP): cv.isfile })) _LOGGER = logging.getLogger(__name__) REQUIREMENTS = ['pexpect==4.0.1'] _LEASES_CMD = 'cat /var/lib/misc/dnsmasq.leases' _LEASES_REGEX = re.compile( r'\w+\s' + r'(?P<mac>(([0-9a-f]{2}[:-]){5}([0-9a-f]{2})))\s' + r'(?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3})\s' +
import logging import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME _LOGGER = logging.getLogger(__name__) CONF_DEFAULT_IP = '169.254.1.1' # This IP is valid for all FRITZ!Box routers. PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_HOST, default=CONF_DEFAULT_IP): cv.string, vol.Optional(CONF_PASSWORD, default='admin'): cv.string, vol.Optional(CONF_USERNAME, default=''): cv.string }) def get_scanner(hass, config): """Validate the configuration and return FritzBoxScanner.""" scanner = FritzBoxScanner(config[DOMAIN]) return scanner if scanner.success_init else None class FritzBoxScanner(DeviceScanner): """This class queries a FRITZ!Box router.""" def __init__(self, config): """Initialize the scanner."""
from requests.exceptions import RequestException import voluptuous as vol from homeassistant.components.device_tracker import (DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import (CONF_HOST, CONF_PASSWORD) import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['quantum-gateway==0.0.3'] _LOGGER = logging.getLogger(__name__) DEFAULT_HOST = 'myfiosgateway.com' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string }) def get_scanner(hass, config): """Validate the configuration and return a Quantum Gateway scanner.""" scanner = QuantumGatewayDeviceScanner(config[DOMAIN]) return scanner if scanner.success_init else None class QuantumGatewayDeviceScanner(DeviceScanner): """This class queries a Quantum Gateway.""" def __init__(self, config): """Initialize the scanner."""
CONF_DEVICES, ATTR_GPS_ACCURACY, ATTR_LATITUDE, ATTR_LONGITUDE, ATTR_BATTERY_LEVEL) DEPENDENCIES = ['mqtt'] _LOGGER = logging.getLogger(__name__) GPS_JSON_PAYLOAD_SCHEMA = vol.Schema({ vol.Required(ATTR_LATITUDE): vol.Coerce(float), vol.Required(ATTR_LONGITUDE): vol.Coerce(float), vol.Optional(ATTR_GPS_ACCURACY, default=None): vol.Coerce(int), vol.Optional(ATTR_BATTERY_LEVEL, default=None): vol.Coerce(str), }, extra=vol.ALLOW_EXTRA) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(mqtt.SCHEMA_BASE).extend({ vol.Required(CONF_DEVICES): {cv.string: mqtt.valid_subscribe_topic}, }) @asyncio.coroutine def async_setup_scanner(hass, config, async_see, discovery_info=None): """Set up the MQTT JSON tracker.""" devices = config[CONF_DEVICES] qos = config[CONF_QOS] dev_id_lookup = {} @callback def async_tracker_message_received(topic, payload, qos): """Handle received MQTT message.""" dev_id = dev_id_lookup[topic]
import homeassistant.helpers.config_validation as cv from homeassistant.helpers.event import async_track_time_interval from homeassistant.components.device_tracker import ( PLATFORM_SCHEMA, CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL) from homeassistant.const import ( CONF_HOST, CONF_PORT) REQUIREMENTS = ['aiofreepybox==0.0.4'] _LOGGER = logging.getLogger(__name__) FREEBOX_CONFIG_FILE = 'freebox.conf' PLATFORM_SCHEMA = vol.All( PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PORT): cv.port })) MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10) async def async_setup_scanner(hass, config, async_see, discovery_info=None): """Set up the Freebox device tracker and start the polling.""" freebox_config = copy.deepcopy(config) if discovery_info is not None: freebox_config[CONF_HOST] = discovery_info['properties']['api_domain'] freebox_config[CONF_PORT] = discovery_info['properties']['https_port'] _LOGGER.info("Discovered Freebox server: %s:%s", freebox_config[CONF_HOST], freebox_config[CONF_PORT]) scanner = FreeboxDeviceScanner(hass, freebox_config, async_see)
import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_DHCP_SOFTWARE = 'dhcp_software' DEFAULT_DHCP_SOFTWARE = 'dnsmasq' DHCP_SOFTWARES = [ 'dnsmasq', 'odhcpd', 'none' ] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_DHCP_SOFTWARE, default=DEFAULT_DHCP_SOFTWARE): vol.In(DHCP_SOFTWARES), }) def get_scanner(hass, config): """Validate the configuration and return an ubus scanner.""" dhcp_sw = config[DOMAIN][CONF_DHCP_SOFTWARE] if dhcp_sw == 'dnsmasq': scanner = DnsmasqUbusDeviceScanner(config[DOMAIN]) elif dhcp_sw == 'odhcpd': scanner = OdhcpdUbusDeviceScanner(config[DOMAIN]) else: scanner = UbusDeviceScanner(config[DOMAIN])
https://home-assistant.io/components/device_tracker.xiaomi_miio/ """ import logging import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.components.device_tracker import (DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import (CONF_HOST, CONF_TOKEN) _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)), }) REQUIREMENTS = ['python-miio==0.4.0', 'construct==2.9.41'] def get_scanner(hass, config): """Return a Xiaomi MiIO device scanner.""" from miio import WifiRepeater, DeviceException scanner = None host = config[DOMAIN].get(CONF_HOST) token = config[DOMAIN].get(CONF_TOKEN) _LOGGER.info("Initializing with host %s (token %s...)", host, token[:5])
# Unifi package doesn't list urllib3 as a requirement REQUIREMENTS = ['urllib3', 'pyunifi==1.3'] _LOGGER = logging.getLogger(__name__) CONF_PORT = 'port' CONF_SITE_ID = 'site_id' NOTIFICATION_ID = 'unifi_notification' NOTIFICATION_TITLE = 'Unifi Device Tracker Setup' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_HOST, default='localhost'): cv.string, vol.Optional(CONF_SITE_ID, default='default'): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PORT, default=8443): cv.port }) def get_scanner(hass, config): """Setup Unifi device_tracker.""" from pyunifi.controller import Controller host = config[DOMAIN].get(CONF_HOST) username = config[DOMAIN].get(CONF_USERNAME) password = config[DOMAIN].get(CONF_PASSWORD) site_id = config[DOMAIN].get(CONF_SITE_ID)
_DDWRT_DATA_REGEX = re.compile(r"\{(\w+)::([^\}]*)\}") _MAC_REGEX = re.compile(r"(([0-9A-Fa-f]{1,2}\:){5}[0-9A-Fa-f]{1,2})") DEFAULT_SSL = False DEFAULT_VERIFY_SSL = True CONF_WIRELESS_ONLY = "wireless_only" DEFAULT_WIRELESS_ONLY = True PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean, vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean, vol.Optional(CONF_WIRELESS_ONLY, default=DEFAULT_WIRELESS_ONLY): cv.boolean, }) def get_scanner(hass, config): """Validate the configuration and return a DD-WRT scanner.""" try: return DdWrtDeviceScanner(config[DOMAIN]) except ConnectionError: return None
REQUIREMENTS = ['pynetgear==0.5.2'] _LOGGER = logging.getLogger(__name__) CONF_APS = 'accesspoints' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_HOST, default=''): cv.string, vol.Optional(CONF_SSL, default=False): cv.boolean, vol.Optional(CONF_USERNAME, default=''): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_PORT, default=None): vol.Any(None, cv.port), vol.Optional(CONF_DEVICES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_EXCLUDE, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_APS, default=[]): vol.All(cv.ensure_list, [cv.string]), }) def get_scanner(hass, config): """Validate the configuration and returns a Netgear scanner.""" info = config[DOMAIN] host = info.get(CONF_HOST) ssl = info.get(CONF_SSL)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_PORT, default=8082): cv.port, vol.Optional(CONF_SSL, default=False): cv.boolean, vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean, vol.Optional(CONF_MONITORED_CONDITIONS, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_EVENT, default=[]): vol.All(cv.ensure_list, [vol.Any(EVENT_DEVICE_MOVING, EVENT_COMMAND_RESULT, EVENT_DEVICE_FUEL_DROP, EVENT_GEOFENCE_ENTER, EVENT_DEVICE_OFFLINE, EVENT_DRIVER_CHANGED, EVENT_GEOFENCE_EXIT, EVENT_DEVICE_OVERSPEED, EVENT_DEVICE_ONLINE, EVENT_DEVICE_STOPPED, EVENT_MAINTENANCE, EVENT_ALARM, EVENT_TEXT_MESSAGE, EVENT_DEVICE_UNKNOWN, EVENT_IGNITION_OFF, EVENT_IGNITION_ON, EVENT_ALL_EVENTS)]), })
) _LOGGER = logging.getLogger(__name__) GPS_JSON_PAYLOAD_SCHEMA = vol.Schema( { vol.Required(ATTR_LATITUDE): vol.Coerce(float), vol.Required(ATTR_LONGITUDE): vol.Coerce(float), vol.Optional(ATTR_GPS_ACCURACY): vol.Coerce(int), vol.Optional(ATTR_BATTERY_LEVEL): vol.Coerce(str), }, extra=vol.ALLOW_EXTRA, ) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(mqtt.SCHEMA_BASE).extend( {vol.Required(CONF_DEVICES): { cv.string: mqtt.valid_subscribe_topic }}) async def async_setup_scanner(hass, config, async_see, discovery_info=None): """Set up the MQTT JSON tracker.""" devices = config[CONF_DEVICES] qos = config[CONF_QOS] for dev_id, topic in devices.items(): @callback def async_message_received(msg, dev_id=dev_id): """Handle received MQTT message.""" try: data = GPS_JSON_PAYLOAD_SCHEMA(json.loads(msg.payload))
DEFAULT_TIMEOUT = 5 DEFAULT_SCOPE = ['location', 'vehicle:profile', 'trip'] FULL_SCOPE = DEFAULT_SCOPE + ['current_location'] ATTR_FUEL_LEVEL = 'fuel_level' EVENT_AUTOMATIC_UPDATE = 'automatic_update' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_CLIENT_ID): cv.string, vol.Required(CONF_SECRET): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_DEVICES, default=None): vol.All(cv.ensure_list, [cv.string]) }) @asyncio.coroutine def async_setup_scanner(hass, config, async_see, discovery_info=None): """Validate the configuration and return an Automatic scanner.""" import aioautomatic client = aioautomatic.Client(client_id=config[CONF_CLIENT_ID], client_secret=config[CONF_SECRET], client_session=async_get_clientsession(hass),
_LOGGER = logging.getLogger(__name__) ATTR_ADDRESS = 'address' ATTR_FULL_NAME = 'full_name' ATTR_LAST_SEEN = 'last_seen' ATTR_NICKNAME = 'nickname' CONF_MAX_GPS_ACCURACY = 'max_gps_accuracy' CREDENTIALS_FILE = '.google_maps_location_sharing.cookies' MIN_TIME_BETWEEN_SCANS = timedelta(seconds=30) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_MAX_GPS_ACCURACY, default=100000): vol.Coerce(float), }) def setup_scanner(hass, config: ConfigType, see, discovery_info=None): """Set up the Google Maps Location sharing scanner.""" scanner = GoogleMapsScanner(hass, config, see) return scanner.success_init class GoogleMapsScanner: """Representation of an Google Maps location sharing account.""" def __init__(self, hass, config: ConfigType, see) -> None: """Initialize the scanner."""
from homeassistant.components.device_tracker.config_entry import ScannerEntity from homeassistant.const import (CONF_URL, CONF_USERNAME, CONF_PASSWORD, CONF_VERIFY_SSL) from .controller import OmadaController from .const import (CONF_SSID_FILTER, CONF_SITE, DATA_OMADA, DOMAIN as OMADA_DOMAIN) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_URL): cv.string, vol.Optional(CONF_SITE, default="Default"): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_SSID_FILTER, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean }) async def async_setup_entry(hass, config_entry, async_add_entities): controller: OmadaController = hass.data[OMADA_DOMAIN][ config_entry.entry_id][DATA_OMADA] controller.entities[DOMAIN] = set() def get_clients_filtered():
from homeassistant.helpers.event import track_point_in_utc_time from homeassistant.components.device_tracker import ( YAML_DEVICES, CONF_TRACK_NEW, CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL, load_config, PLATFORM_SCHEMA, DEFAULT_TRACK_NEW, SOURCE_TYPE_BLUETOOTH) import homeassistant.util.dt as dt_util _LOGGER = logging.getLogger(__name__) REQUIREMENTS = ['pybluez==0.22', 'bt_proximity==0.1.2'] BT_PREFIX = 'BT_' CONF_REQUEST_RSSI = 'request_rssi' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_TRACK_NEW): cv.boolean, vol.Optional(CONF_REQUEST_RSSI): cv.boolean }) def setup_scanner(hass, config, see, discovery_info=None): """Set up the Bluetooth Scanner.""" # pylint: disable=import-error import bluetooth from bt_proximity import BluetoothRSSI def see_device(mac, name, rssi=None): """Mark a device as seen.""" attributes = {} if rssi is not None: attributes['rssi'] = rssi see(mac="{}_{}".format(BT_PREFIX, mac), host_name=name,
import requests import voluptuous as vol from homeassistant.components.device_tracker import (DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import (CONF_HOST, CONF_PASSWORD, CONF_USERNAME, HTTP_HEADER_X_REQUESTED_WITH) import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) HTTP_HEADER_NO_CACHE = 'no-cache' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string }) def get_scanner(hass, config): """Validate the configuration and return a TP-Link scanner.""" for cls in [ Tplink5DeviceScanner, Tplink4DeviceScanner, Tplink3DeviceScanner, Tplink2DeviceScanner, TplinkDeviceScanner ]: scanner = cls(config[DOMAIN]) if scanner.success_init: return scanner return None
from homeassistant.util import Throttle # Return cached results if last scan was less then this time ago MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5) _LOGGER = logging.getLogger(__name__) # Interval in minutes to exclude devices from a scan while they are home CONF_HOME_INTERVAL = 'home_interval' CONF_EXCLUDE = 'exclude' REQUIREMENTS = ['python-nmap==0.6.1'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOSTS): cv.ensure_list, vol.Required(CONF_HOME_INTERVAL, default=0): cv.positive_int, vol.Optional(CONF_EXCLUDE, default=[]): vol.All(cv.ensure_list, vol.Length(min=1)) }) def get_scanner(hass, config): """Validate the configuration and return a Nmap scanner.""" scanner = NmapDeviceScanner(config[DOMAIN]) return scanner if scanner.success_init else None Device = namedtuple('Device', ['mac', 'name', 'ip', 'last_update']) def _arp(ip_address): """Get the MAC address for a given IP."""
CONF_COMMUNITY = 'community' CONF_AUTHKEY = 'authkey' CONF_PRIVKEY = 'privkey' CONF_BASEOID = 'baseoid' DEFAULT_COMMUNITY = 'public' MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_COMMUNITY, default=DEFAULT_COMMUNITY): cv.string, vol.Inclusive(CONF_AUTHKEY, 'keys'): cv.string, vol.Inclusive(CONF_PRIVKEY, 'keys'): cv.string, vol.Required(CONF_BASEOID): cv.string }) # pylint: disable=unused-argument def get_scanner(hass, config): """Validate the configuration and return an snmp scanner.""" scanner = SnmpScanner(config[DOMAIN]) return scanner if scanner.success_init else None
CONF_MQTT_TOPIC = 'mqtt_topic' CONF_REGION_MAPPING = 'region_mapping' CONF_EVENTS_ONLY = 'events_only' DEPENDENCIES = ['mqtt'] DEFAULT_OWNTRACKS_TOPIC = 'owntracks/#' REGION_MAPPING = {} PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_MAX_GPS_ACCURACY): vol.Coerce(float), vol.Optional(CONF_WAYPOINT_IMPORT, default=True): cv.boolean, vol.Optional(CONF_EVENTS_ONLY, default=False): cv.boolean, vol.Optional(CONF_MQTT_TOPIC, default=DEFAULT_OWNTRACKS_TOPIC): mqtt.valid_subscribe_topic, vol.Optional(CONF_WAYPOINT_WHITELIST): vol.All( cv.ensure_list, [cv.string]), vol.Optional(CONF_SECRET): vol.Any( vol.Schema({vol.Optional(cv.string): cv.string}), cv.string), vol.Optional(CONF_REGION_MAPPING, default=REGION_MAPPING): dict }) def get_cipher(): """Return decryption function and length of key. Async friendly. """ from libnacl import crypto_secretbox_KEYBYTES as KEYLEN from libnacl.secret import SecretBox
EVENT_ALL_EVENTS, ] PLATFORM_SCHEMA = PARENT_PLATFORM_SCHEMA.extend({ vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_PORT, default=8082): cv.port, vol.Optional(CONF_SSL, default=False): cv.boolean, vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean, vol.Required(CONF_MAX_ACCURACY, default=0): cv.positive_int, vol.Optional(CONF_SKIP_ACCURACY_ON, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_MONITORED_CONDITIONS, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_EVENT, default=[]): vol.All( cv.ensure_list, [vol.In(EVENTS)], ), }) async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry,
import homeassistant.helpers.config_validation as cv from homeassistant.const import CONF_USERNAME, CONF_PASSWORD from homeassistant.util import Throttle from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.helpers.aiohttp_client import async_create_clientsession _LOGGER = logging.getLogger(__name__) CONF_HOME_ID = 'home_id' MIN_TIME_BETWEEN_SCANS = timedelta(seconds=30) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_HOME_ID): cv.string, }) def get_scanner(hass, config): """Return a Tado scanner.""" scanner = TadoDeviceScanner(hass, config[DOMAIN]) return scanner if scanner.success_init else None Device = namedtuple("Device", ["mac", "name"]) class TadoDeviceScanner(DeviceScanner): """This class gets geofenced devices from Tado."""
import homeassistant.helpers.config_validation as cv from homeassistant.util.async_ import run_callback_threadsafe from homeassistant.util.process import kill_subprocess from . import async_get_next_ping_id from .const import PING_ATTEMPTS_COUNT, PING_TIMEOUT _LOGGER = logging.getLogger(__name__) PARALLEL_UPDATES = 0 CONF_PING_COUNT = "count" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(const.CONF_HOSTS): { cv.slug: cv.string }, vol.Optional(CONF_PING_COUNT, default=1): cv.positive_int, }) class HostSubProcess: """Host object with ping detection.""" def __init__(self, ip_address, dev_id, hass, config): """Initialize the Host pinger.""" self.hass = hass self.ip_address = ip_address self.dev_id = dev_id self._count = config[CONF_PING_COUNT] if sys.platform == "win32": self._ping_cmd = ["ping", "-n", "1", "-w", "1000", self.ip_address]
LOCATION_TOPIC = 'owntracks/+/+' VALIDATE_LOCATION = 'location' VALIDATE_TRANSITION = 'transition' VALIDATE_WAYPOINTS = 'waypoints' WAYPOINT_LAT_KEY = 'lat' WAYPOINT_LON_KEY = 'lon' WAYPOINT_TOPIC = 'owntracks/{}/{}/waypoint' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_MAX_GPS_ACCURACY): vol.Coerce(float), vol.Optional(CONF_WAYPOINT_IMPORT, default=True): cv.boolean, vol.Optional(CONF_WAYPOINT_WHITELIST): vol.All( cv.ensure_list, [cv.string]), vol.Optional(CONF_SECRET): vol.Any( vol.Schema({vol.Optional(cv.string): cv.string}), cv.string) }) def get_cipher(): """Return decryption function and length of key. Async friendly. """ from libnacl import crypto_secretbox_KEYBYTES as KEYLEN from libnacl.secret import SecretBox def decrypt(ciphertext, key):
CONF_SITE_ID = 'site_id' DEFAULT_HOST = 'localhost' DEFAULT_PORT = 8443 DEFAULT_VERIFY_SSL = True NOTIFICATION_ID = 'unifi_notification' NOTIFICATION_TITLE = 'Unifi Device Tracker Setup' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_SITE_ID, default='default'): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean, }) def get_scanner(hass, config): """Set up the Unifi device_tracker.""" from pyunifi.controller import Controller host = config[DOMAIN].get(CONF_HOST) username = config[DOMAIN].get(CONF_USERNAME) password = config[DOMAIN].get(CONF_PASSWORD)
import homeassistant.helpers.config_validation as cv from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import ( CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_VERIFY_SSL) INTERFACES = 2 DEFAULT_TIMEOUT = 10 REQUIREMENTS = ['beautifulsoup4==4.6.0'] _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean, }) def get_scanner(hass, config): """Validate the configuration and return a Linksys AP scanner.""" try: return LinksysAPDeviceScanner(config[DOMAIN]) except ConnectionError: return None class LinksysAPDeviceScanner(DeviceScanner): """This class queries a Linksys Access Point."""
import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.exceptions import HomeAssistantError from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import ( CONF_HOST, CONF_USERNAME, CONF_PASSWORD, CONF_SSL) _LOGGER = logging.getLogger(__name__) DEFAULT_SSL = False 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_SSL, default=DEFAULT_SSL): cv.boolean }) class InvalidLuciTokenError(HomeAssistantError): """When an invalid token is detected.""" pass def get_scanner(hass, config): """Validate the configuration and return a Luci scanner.""" scanner = LuciDeviceScanner(config[DOMAIN]) return scanner if scanner.success_init else None
CONF_USERNAME, CONF_PORT) from homeassistant.util import Throttle REQUIREMENTS = ['librouteros==1.0.2'] # Return cached results if last scan was less then this time ago. MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10) MTK_DEFAULT_API_PORT = '8728' _LOGGER = logging.getLogger(__name__) 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_PORT, default=MTK_DEFAULT_API_PORT): cv.port }) def get_scanner(hass, config): """Validate the configuration and return MTikScanner.""" scanner = MikrotikScanner(config[DOMAIN]) return scanner if scanner.success_init else None class MikrotikScanner(DeviceScanner): """This class queries a Mikrotik router.""" def __init__(self, config): """Initialize the scanner."""
REQUIREMENTS = ['pexpect==4.0.1'] _LOGGER = logging.getLogger(__name__) CONF_PUB_KEY = 'pub_key' CONF_SSH_KEY = 'ssh_key' DEFAULT_SSH_PORT = 22 SECRET_GROUP = 'Password or SSH Key' PLATFORM_SCHEMA = vol.All( cv.has_at_least_one_key(CONF_PASSWORD, CONF_PUB_KEY, CONF_SSH_KEY), PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_PROTOCOL, default='ssh'): vol.In(['ssh', 'telnet']), vol.Optional(CONF_MODE, default='router'): vol.In(['router', 'ap']), vol.Optional(CONF_PORT, default=DEFAULT_SSH_PORT): cv.port, vol.Exclusive(CONF_PASSWORD, SECRET_GROUP): cv.string, vol.Exclusive(CONF_SSH_KEY, SECRET_GROUP): cv.isfile, vol.Exclusive(CONF_PUB_KEY, SECRET_GROUP): cv.isfile })) _LEASES_CMD = 'cat /var/lib/misc/dnsmasq.leases' _LEASES_REGEX = re.compile( r'\w+\s' + r'(?P<mac>(([0-9a-f]{2}[:-]){5}([0-9a-f]{2})))\s' + r'(?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3})\s' + r'(?P<host>([^\s]+))') # Command to get both 5GHz and 2.4GHz clients _WL_CMD = 'for dev in `nvram get wl_ifnames`; do wl -i $dev assoclist; done'
CLIENT_UUID_CONFIG_FILE = '.tile.conf' DEFAULT_ICON = 'mdi:bluetooth' DEVICE_TYPES = ['PHONE', 'TILE'] ATTR_ALTITUDE = 'altitude' ATTR_CONNECTION_STATE = 'connection_state' ATTR_IS_DEAD = 'is_dead' ATTR_IS_LOST = 'is_lost' ATTR_LAST_SEEN = 'last_seen' ATTR_LAST_UPDATED = 'last_updated' ATTR_RING_STATE = 'ring_state' ATTR_VOIP_STATE = 'voip_state' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_MONITORED_VARIABLES): vol.All(cv.ensure_list, [vol.In(DEVICE_TYPES)]), }) def setup_scanner(hass, config: dict, see, discovery_info=None): """Validate the configuration and return a Tile scanner.""" TileDeviceScanner(hass, config, see) return True class TileDeviceScanner(DeviceScanner): """Define a device scanner for Tiles.""" def __init__(self, hass, config, see): """Initialize."""
DeviceScanner) from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME from homeassistant.exceptions import HomeAssistantError import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_DHCP_SOFTWARE = 'dhcp_software' DEFAULT_DHCP_SOFTWARE = 'dnsmasq' DHCP_SOFTWARES = ['dnsmasq', 'odhcpd', 'none'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_DHCP_SOFTWARE, default=DEFAULT_DHCP_SOFTWARE): vol.In(DHCP_SOFTWARES), }) def get_scanner(hass, config): """Validate the configuration and return an ubus scanner.""" dhcp_sw = config[DOMAIN][CONF_DHCP_SOFTWARE] if dhcp_sw == 'dnsmasq': scanner = DnsmasqUbusDeviceScanner(config[DOMAIN]) elif dhcp_sw == 'odhcpd': scanner = OdhcpdUbusDeviceScanner(config[DOMAIN]) else: scanner = UbusDeviceScanner(config[DOMAIN])
CONF_DEVICES = 'devices' CONF_SECRET = 'secret' DATA_CONFIGURING = 'automatic_configurator_clients' DATA_REFRESH_TOKEN = 'refresh_token' DEFAULT_SCOPE = ['location', 'trip', 'vehicle:events', 'vehicle:profile'] DEFAULT_TIMEOUT = 5 DEPENDENCIES = ['http'] EVENT_AUTOMATIC_UPDATE = 'automatic_update' FULL_SCOPE = DEFAULT_SCOPE + ['current_location'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_CLIENT_ID): cv.string, vol.Required(CONF_SECRET): cv.string, vol.Optional(CONF_CURRENT_LOCATION, default=False): cv.boolean, vol.Optional(CONF_DEVICES): vol.All(cv.ensure_list, [cv.string]), }) def _get_refresh_token_from_file(hass, filename): """Attempt to load session data from file.""" path = hass.config.path(filename) if not os.path.isfile(path): return None try: with open(path) as data_file: data = json.load(data_file) if data is None:
CONF_CALLSIGNS = 'callsigns' DEFAULT_HOST = 'rotate.aprs2.net' DEFAULT_PASSWORD = '******' DEFAULT_TIMEOUT = 30.0 FILTER_PORT = 14580 MSG_FORMATS = ['compressed', 'uncompressed', 'mic-e'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_CALLSIGNS): cv.ensure_list, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_PASSWORD, default=DEFAULT_PASSWORD): cv.string, vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): vol.Coerce(float), }) def make_filter(callsigns: list) -> str: """Make a server-side filter from a list of callsigns.""" return ' '.join('b/{0}'.format(cs.upper()) for cs in callsigns) def gps_accuracy(gps, posambiguity: int) -> int: """Calculate the GPS accuracy based on APRS posambiguity.""" import geopy.distance
"""Support for Xiaomi Mi WiFi Repeater 2.""" import logging import voluptuous as vol from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import CONF_HOST, CONF_TOKEN import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['python-miio==0.4.5', 'construct==2.9.45'] _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)), }) def get_scanner(hass, config): """Return a Xiaomi MiIO device scanner.""" from miio import WifiRepeater, DeviceException scanner = None host = config[DOMAIN].get(CONF_HOST) token = config[DOMAIN].get(CONF_TOKEN) _LOGGER.info( "Initializing with host %s (token %s...)", host, token[:5]) try:
import homeassistant.helpers.config_validation as cv from homeassistant.const import CONF_USERNAME, CONF_PASSWORD from homeassistant.util import Throttle from homeassistant.components.device_tracker import (DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.helpers.aiohttp_client import async_create_clientsession _LOGGER = logging.getLogger(__name__) CONF_HOME_ID = 'home_id' MIN_TIME_BETWEEN_SCANS = timedelta(seconds=30) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_HOME_ID): cv.string, }) def get_scanner(hass, config): """Return a Tado scanner.""" scanner = TadoDeviceScanner(hass, config[DOMAIN]) return scanner if scanner.success_init else None Device = namedtuple("Device", ["mac", "name"]) class TadoDeviceScanner(DeviceScanner): """This class gets geofenced devices from Tado."""
_LOGGER = logging.getLogger(__name__) # Interface name to track devices for. Most likely one will not need to # change it from default 'Home'. This is needed not to track Guest WI-FI- # clients and router itself CONF_INTERFACE = 'interface' DEFAULT_INTERFACE = 'Home' DEFAULT_PORT = 23 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_INTERFACE, default=DEFAULT_INTERFACE): cv.string, }) def get_scanner(_hass, config): """Validate the configuration and return a Nmap scanner.""" scanner = KeeneticNDMS2DeviceScanner(config[DOMAIN]) return scanner if scanner.success_init else None class KeeneticNDMS2DeviceScanner(DeviceScanner): """This class scans for devices using keenetic NDMS2 web interface."""
DeviceScanner) from homeassistant.const import (CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_VERIFY_SSL) INTERFACES = 2 DEFAULT_TIMEOUT = 10 REQUIREMENTS = ['beautifulsoup4==4.6.1'] _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean, }) def get_scanner(hass, config): """Validate the configuration and return a Linksys AP scanner.""" try: return LinksysAPDeviceScanner(config[DOMAIN]) except ConnectionError: return None class LinksysAPDeviceScanner(DeviceScanner):
REQUIREMENTS = ['aioautomatic==0.2.1'] _LOGGER = logging.getLogger(__name__) CONF_CLIENT_ID = 'client_id' CONF_SECRET = 'secret' CONF_DEVICES = 'devices' DEFAULT_TIMEOUT = 5 SCOPE = ['location', 'vehicle:profile', 'trip'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_CLIENT_ID): cv.string, vol.Required(CONF_SECRET): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_DEVICES, default=None): vol.All( cv.ensure_list, [cv.string]) }) @asyncio.coroutine def async_setup_scanner(hass, config, async_see, discovery_info=None): """Validate the configuration and return an Automatic scanner.""" import aioautomatic client = aioautomatic.Client( client_id=config[CONF_CLIENT_ID], client_secret=config[CONF_SECRET], client_session=async_get_clientsession(hass), request_kwargs={'timeout': DEFAULT_TIMEOUT})
import homeassistant.helpers.config_validation as cv from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.components.device_tracker import (DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import CONF_HOST REQUIREMENTS = ['ghlocalapi==0.3.5'] _LOGGER = logging.getLogger(__name__) CONF_RSSI_THRESHOLD = 'rssi_threshold' PLATFORM_SCHEMA = vol.All( PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_RSSI_THRESHOLD, default=-70): vol.Coerce(int), })) async def async_get_scanner(hass, config): """Validate the configuration and return an Google Home scanner.""" scanner = GoogleHomeDeviceScanner(hass, config[DOMAIN]) await scanner.async_connect() return scanner if scanner.success_init else None class GoogleHomeDeviceScanner(DeviceScanner): """This class queries a Google Home unit.""" def __init__(self, hass, config): """Initialize the scanner."""
from homeassistant.core import callback from homeassistant.components.http import HomeAssistantView from homeassistant.components.device_tracker import ( PLATFORM_SCHEMA, SOURCE_TYPE_ROUTER) CONF_VALIDATOR = 'validator' CONF_SECRET = 'secret' URL = '/api/meraki' VERSION = '2.0' _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_VALIDATOR): cv.string, vol.Required(CONF_SECRET): cv.string }) async def async_setup_scanner(hass, config, async_see, discovery_info=None): """Set up an endpoint for the Meraki tracker.""" hass.http.register_view( MerakiView(config, async_see)) return True class MerakiView(HomeAssistantView): """View to handle Meraki requests.""" url = URL
from homeassistant.const import (CONF_HOST, CONF_PASSWORD, CONF_USERNAME) import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_MODEL = 'model' DEFAULT_MODEL = 'detect' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_MODEL, default=DEFAULT_MODEL): vol.Any( 'EVW32C-0N', 'EVW320B', 'EVW321B', 'EVW3200-Wifi', 'EVW3226@UPC', ), }) def get_scanner(hass, config): """Validate the configuration and return a Ubee scanner.""" info = config[DOMAIN] host = info[CONF_HOST] username = info[CONF_USERNAME] password = info[CONF_PASSWORD]
import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA from homeassistant.const import CONF_HOST from homeassistant.util import Throttle # Return cached results if last scan was less then this time ago. MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10) _LOGGER = logging.getLogger(__name__) _MAC_REGEX = re.compile(r'(([0-9A-Fa-f]{1,2}\:){5}[0-9A-Fa-f]{1,2})') PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string }) # pylint: disable=unused-argument def get_scanner(hass, config): """Return a BT Home Hub 5 scanner if successful.""" scanner = BTHomeHub5DeviceScanner(config[DOMAIN]) return scanner if scanner.success_init else None class BTHomeHub5DeviceScanner(object): """This class queries a BT Home Hub 5.""" def __init__(self, config):
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_MODEL = "model" DEFAULT_MODEL = "detect" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_MODEL, default=DEFAULT_MODEL): vol.Any( "EVW32C-0N", "EVW320B", "EVW321B", "EVW3200-Wifi", "EVW3226@UPC", "DVW32CB", "DDW36C", ), } ) def get_scanner(hass, config): """Validate the configuration and return a Ubee scanner.""" info = config[DOMAIN] host = info[CONF_HOST] username = info[CONF_USERNAME] password = info[CONF_PASSWORD]
from homeassistant.const import ( CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_PORT, CONF_SSL, CONF_METHOD) _LOGGER = logging.getLogger(__name__) MTK_DEFAULT_API_PORT = '8728' MTK_DEFAULT_API_SSL_PORT = '8729' CONF_ENCODING = 'encoding' DEFAULT_ENCODING = 'utf-8' 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_METHOD): cv.string, vol.Optional(CONF_PORT): cv.port, vol.Optional(CONF_SSL, default=False): cv.boolean, vol.Optional(CONF_ENCODING, default=DEFAULT_ENCODING): cv.string, }) def get_scanner(hass, config): """Validate the configuration and return MTikScanner.""" scanner = MikrotikScanner(config[DOMAIN]) return scanner if scanner.success_init else None class MikrotikScanner(DeviceScanner): """This class queries a Mikrotik router."""
SERVICE_SCHEMA = vol.Schema({ vol.Optional(ATTR_ACCOUNTNAME): vol.All(cv.ensure_list, [cv.slugify]), vol.Optional(ATTR_DEVICENAME): cv.slugify, vol.Optional(ATTR_INTERVAL): cv.positive_int }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(ATTR_ACCOUNTNAME): cv.slugify, vol.Optional(CONF_MAX_INTERVAL, default=30): cv.positive_int, vol.Optional(CONF_GPS_ACCURACY_THRESHOLD, default=1000): cv.positive_int }) def setup_scanner(hass, config: dict, see, discovery_info=None): """Set up the iCloud Scanner.""" username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) account = config.get(CONF_ACCOUNTNAME, slugify(username.partition('@')[0])) max_interval = config.get(CONF_MAX_INTERVAL) gps_accuracy_threshold = config.get(CONF_GPS_ACCURACY_THRESHOLD)
) from homeassistant.components.http import ( CONF_API_PASSWORD, HomeAssistantView ) # pylint: disable=unused-import from homeassistant.components.device_tracker import ( # NOQA DOMAIN, PLATFORM_SCHEMA ) from homeassistant.helpers.typing import HomeAssistantType, ConfigType _LOGGER = logging.getLogger(__name__) DEPENDENCIES = ['http'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_PASSWORD): cv.string, }) async def async_setup_scanner(hass: HomeAssistantType, config: ConfigType, async_see, discovery_info=None): """Set up an endpoint for the GPSLogger application.""" hass.http.register_view(GPSLoggerView(async_see, config)) return True class GPSLoggerView(HomeAssistantView): """View to handle GPSLogger requests.""" url = '/api/gpslogger'
from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, \ CONF_PORT from homeassistant.util import Throttle # Return cached results if last scan was less then this time ago. MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5) _LOGGER = logging.getLogger(__name__) REQUIREMENTS = ['pexpect==4.0.1'] PLATFORM_SCHEMA = vol.All( PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_PASSWORD, default=''): cv.string, vol.Optional(CONF_PORT): cv.port, })) def get_scanner(hass, config): """Validate the configuration and return a Cisco scanner.""" scanner = CiscoDeviceScanner(config[DOMAIN]) return scanner if scanner.success_init else None class CiscoDeviceScanner(object): """This class queries a wireless router running Cisco IOS firmware.""" def __init__(self, config): """Initialize the scanner."""
import homeassistant.helpers.config_validation as cv from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import CONF_HOST from homeassistant.helpers.aiohttp_client import async_get_clientsession REQUIREMENTS = ['defusedxml==0.5.0'] _LOGGER = logging.getLogger(__name__) DEFAULT_IP = '192.168.0.1' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_HOST, default=DEFAULT_IP): cv.string, }) CMD_DEVICES = 123 @asyncio.coroutine def async_get_scanner(hass, config): """Return the UPC device scanner.""" scanner = UPCDeviceScanner(hass, config[DOMAIN]) success_init = yield from scanner.async_initialize_token() return scanner if success_init else None class UPCDeviceScanner(DeviceScanner):
from homeassistant.components.device_tracker import (DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import (CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_PORT) REQUIREMENTS = ['librouteros==1.0.4'] MTK_DEFAULT_API_PORT = '8728' _LOGGER = logging.getLogger(__name__) 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_PORT, default=MTK_DEFAULT_API_PORT): cv.port }) def get_scanner(hass, config): """Validate the configuration and return MTikScanner.""" scanner = MikrotikScanner(config[DOMAIN]) return scanner if scanner.success_init else None class MikrotikScanner(DeviceScanner): """This class queries a Mikrotik router.""" def __init__(self, config):
PLATFORM_SCHEMA, load_config ) import homeassistant.util.dt as dt_util import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) REQUIREMENTS = ['gattlib==0.20150805'] BLE_PREFIX = 'BLE_' MIN_SEEN_NEW = 5 CONF_SCAN_DURATION = "scan_duration" CONF_BLUETOOTH_DEVICE = "device_id" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_SCAN_DURATION, default=10): cv.positive_int, vol.Optional(CONF_BLUETOOTH_DEVICE, default="hci0"): cv.string }) def setup_scanner(hass, config, see, discovery_info=None): """Setup the Bluetooth LE Scanner.""" # pylint: disable=import-error from gattlib import DiscoveryService new_devices = {} def see_device(address, name, new_device=False): """Mark a device as seen.""" if new_device: if address in new_devices: _LOGGER.debug("Seen %s %s times", address,
import requests import voluptuous as vol from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner, ) from homeassistant.const import CONF_HOST import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DEFAULT_IP = "192.168.1.1" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Optional(CONF_HOST, default=DEFAULT_IP): cv.string}) def get_scanner(hass, config): """Return the Swisscom device scanner.""" scanner = SwisscomDeviceScanner(config[DOMAIN]) return scanner if scanner.success_init else None class SwisscomDeviceScanner(DeviceScanner): """This class queries a router running Swisscom Internet-Box firmware.""" def __init__(self, config): """Initialize the scanner.""" self.host = config[CONF_HOST] self.last_results = {}
from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, \ CONF_PORT from homeassistant.util import Throttle MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5) _LOGGER = logging.getLogger(__name__) REQUIREMENTS = ['pexpect==4.0.1'] PLATFORM_SCHEMA = vol.All( PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_PASSWORD, default=''): cv.string, vol.Optional(CONF_PORT): cv.port, }) ) def get_scanner(hass, config): """Validate the configuration and return a Cisco scanner.""" scanner = CiscoDeviceScanner(config[DOMAIN]) return scanner if scanner.success_init else None class CiscoDeviceScanner(DeviceScanner): """This class queries a wireless router running Cisco IOS firmware."""
import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.helpers.event import track_point_in_utc_time from homeassistant.components.device_tracker import ( YAML_DEVICES, CONF_TRACK_NEW, CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL, load_config, PLATFORM_SCHEMA, DEFAULT_TRACK_NEW) import homeassistant.util.dt as dt_util _LOGGER = logging.getLogger(__name__) REQUIREMENTS = ['zeroconf==0.19.0'] SS_PREFIX = 'SS_' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Optional(CONF_TRACK_NEW): cv.boolean}) class SleepCycleHosts(object): def __init__(self): self.found_services = set() def add_service(self, zc, type_, name): name = name.split('.')[0] self.found_services.add(name) def remove_service(self, zc, type_, name): pass @classmethod def find(cls, timeout=2):
import homeassistant.helpers.config_validation as cv from homeassistant.components.device_tracker import DOMAIN, PLATFORM_SCHEMA from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD # Unifi package doesn't list urllib3 as a requirement REQUIREMENTS = ["urllib3", "unifi==1.2.5"] _LOGGER = logging.getLogger(__name__) CONF_PORT = "port" CONF_SITE_ID = "site_id" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_HOST, default="localhost"): cv.string, vol.Optional(CONF_SITE_ID, default="default"): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PORT, default=8443): cv.port, } ) def get_scanner(hass, config): """Setup Unifi device_tracker.""" from unifi.controller import Controller host = config[DOMAIN].get(CONF_HOST) username = config[DOMAIN].get(CONF_USERNAME) password = config[DOMAIN].get(CONF_PASSWORD) site_id = config[DOMAIN].get(CONF_SITE_ID) port = config[DOMAIN].get(CONF_PORT)
CONF_DT_SITE_ID = "site_id" DEFAULT_HOST = "localhost" DEFAULT_PORT = 8443 DEFAULT_VERIFY_SSL = True DEFAULT_DETECTION_TIME = timedelta(seconds=300) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_DT_SITE_ID, default="default"): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): vol.Any(cv.boolean, cv.isfile), }, extra=vol.ALLOW_EXTRA, ) async def async_setup_scanner(hass, config, sync_see, discovery_info): """Set up the Unifi integration.""" config[CONF_SITE_ID] = config.pop(CONF_DT_SITE_ID) # Current from legacy exist = False
import homeassistant.helpers.config_validation as cv from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME from homeassistant.util import Throttle # Return cached results if last scan was less then this time ago. MIN_TIME_BETWEEN_SCANS = timedelta(seconds=5) CONF_HTTP_ID = "http_id" _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_HTTP_ID): cv.string }) def get_scanner(hass, config): """Validate the configuration and returns a Tomato scanner.""" return TomatoDeviceScanner(config[DOMAIN]) class TomatoDeviceScanner(DeviceScanner): """This class queries a wireless router running Tomato firmware.""" def __init__(self, config): """Initialize the scanner.""" host, http_id = config[CONF_HOST], config[CONF_HTTP_ID]
from homeassistant.components.device_tracker import ( DOMAIN, PLATFORM_SCHEMA, DeviceScanner) from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_VERSION = 'version' CONF_DEFAULT_IP = '192.168.1.1' CONF_DEFAULT_USERNAME = '******' CONF_DEFAULT_VERSION = 2 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_VERSION, default=CONF_DEFAULT_VERSION): cv.positive_int, vol.Required(CONF_HOST, default=CONF_DEFAULT_IP): cv.string, vol.Required(CONF_USERNAME, default=CONF_DEFAULT_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, }) def get_scanner(hass, config): """Return a router scanner instance.""" scanner = EEBrightBoxScanner(config[DOMAIN]) return scanner if scanner.check_config() else None class EEBrightBoxScanner(DeviceScanner): """Scan EE Brightbox router.""" def __init__(self, config):
REQUIREMENTS = ['pysnmp==4.4.2'] _LOGGER = logging.getLogger(__name__) CONF_AUTHKEY = 'authkey' CONF_BASEOID = 'baseoid' CONF_COMMUNITY = 'community' CONF_PRIVKEY = 'privkey' DEFAULT_COMMUNITY = 'public' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_BASEOID): cv.string, vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_COMMUNITY, default=DEFAULT_COMMUNITY): cv.string, vol.Inclusive(CONF_AUTHKEY, 'keys'): cv.string, vol.Inclusive(CONF_PRIVKEY, 'keys'): cv.string, }) # pylint: disable=unused-argument def get_scanner(hass, config): """Validate the configuration and return an SNMP scanner.""" scanner = SnmpScanner(config[DOMAIN]) return scanner if scanner.success_init else None class SnmpScanner(DeviceScanner): """Queries any SNMP capable Access Point for connected devices."""
from homeassistant.util import dt as dt_util, slugify _LOGGER = logging.getLogger(__name__) ATTR_ADDRESS = "address" ATTR_FULL_NAME = "full_name" ATTR_LAST_SEEN = "last_seen" ATTR_NICKNAME = "nickname" CONF_MAX_GPS_ACCURACY = "max_gps_accuracy" CREDENTIALS_FILE = ".google_maps_location_sharing.cookies" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_MAX_GPS_ACCURACY, default=100000): vol.Coerce(float), } ) def setup_scanner(hass, config: ConfigType, see, discovery_info=None): """Set up the Google Maps Location sharing scanner.""" scanner = GoogleMapsScanner(hass, config, see) return scanner.success_init class GoogleMapsScanner: """Representation of an Google Maps location sharing account.""" def __init__(self, hass, config: ConfigType, see) -> None: """Initialize the scanner."""