def setUpModule(): # pylint: disable=invalid-name """ Initalizes a Home Assistant server and Slave instance. """ global hass, slave, master_api, broken_api hass = ha.HomeAssistant() hass.bus.listen('test_event', lambda _: _) hass.states.set('test.test', 'a_state') http.setup( hass, { http.DOMAIN: { http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: 8122 } }) hass.start() master_api = remote.API("127.0.0.1", API_PASSWORD, 8122) # Start slave slave = remote.HomeAssistant(master_api) slave.start() # Setup API pointing at nothing broken_api = remote.API("127.0.0.1", "", 8125)
def test_home_assistant_init(self): """ Test HomeAssistant init. """ # Wrong password self.assertRaises(ha.HomeAssistantError, remote.HomeAssistant, remote.API('127.0.0.1', API_PASSWORD + 'A', 8124)) # Wrong port self.assertRaises(ha.HomeAssistantError, remote.HomeAssistant, remote.API('127.0.0.1', API_PASSWORD, 8125))
def __init__(self, ha_ip, ha_passw, tg_token): self.alive = True self.bot = telegram.Bot(token=tg_token) self.api = remote.API(ha_ip, ha_passw) try: remote.validate_api(self.api) self.bot.getMe() except: self.teardown() try: self.last_update_id = self.bot.getUpdates()[-1].update_id except IndexError: self.last_update_id = None #except telegram.TelegramError: #self.last_update_id = None self.sensors = self.get_homeassistant_sensors() # access control self.trusted_users = [] self.admins = [] self.token = ''.join( random.choice(string.ascii_lowercase + string.ascii_uppercase + string.digits) for x in range(10))
def test_validate_api(self): """ Test Python API validate_api. """ self.assertEqual(remote.APIStatus.OK, remote.validate_api(master_api)) self.assertEqual( remote.APIStatus.INVALID_PASSWORD, remote.validate_api(remote.API("127.0.0.1", API_PASSWORD + "A")))
def post(self, request): """Setup an event forwarder.""" try: data = yield from request.json() except ValueError: return self.json_message("No data received.", HTTP_BAD_REQUEST) try: host = data['host'] api_password = data['api_password'] except KeyError: return self.json_message("No host or api_password received.", HTTP_BAD_REQUEST) try: port = int(data['port']) if 'port' in data else None except ValueError: return self.json_message("Invalid value received for port.", HTTP_UNPROCESSABLE_ENTITY) api = rem.API(host, api_password, port) valid = yield from self.hass.loop.run_in_executor( None, api.validate_api) if not valid: return self.json_message("Unable to validate API.", HTTP_UNPROCESSABLE_ENTITY) if self.event_forwarder is None: self.event_forwarder = rem.EventForwarder(self.hass) self.event_forwarder.async_connect(api) return self.json_message("Event forwarding setup.")
def setUpModule(): # pylint: disable=invalid-name """ Initalizes a Home Assistant server and Slave instance. """ global hass, slave, master_api hass = get_test_home_assistant() hass.bus.listen('test_event', lambda _: _) hass.states.set('test.test', 'a_state') bootstrap.setup_component( hass, http.DOMAIN, { http.DOMAIN: { http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: MASTER_PORT } }) bootstrap.setup_component(hass, 'api') hass.start() master_api = remote.API("127.0.0.1", API_PASSWORD, MASTER_PORT) # Start slave slave = remote.HomeAssistant(master_api) bootstrap.setup_component( slave, http.DOMAIN, { http.DOMAIN: { http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: SLAVE_PORT } }) slave.start()
def _handle_post_api_event_forward(handler, path_match, data): """Handle adding an event forwarding target.""" try: host = data['host'] api_password = data['api_password'] except KeyError: handler.write_json_message( "No host or api_password received.", HTTP_BAD_REQUEST) return try: port = int(data['port']) if 'port' in data else None except ValueError: handler.write_json_message( "Invalid value received for port", HTTP_UNPROCESSABLE_ENTITY) return api = rem.API(host, api_password, port) if not api.validate_api(): handler.write_json_message( "Unable to validate API", HTTP_UNPROCESSABLE_ENTITY) return if handler.server.event_forwarder is None: handler.server.event_forwarder = \ rem.EventForwarder(handler.server.hass) handler.server.event_forwarder.connect(api) handler.write_json_message("Event forwarding setup.")
def setup(hass, config): """ Sets up the HTTP API and debug interface. """ if not util.validate_config(config, {DOMAIN: [CONF_API_PASSWORD]}, _LOGGER): return False api_password = config[DOMAIN]['api_password'] # If no server host is given, accept all incoming requests server_host = config[DOMAIN].get(CONF_SERVER_HOST, '0.0.0.0') server_port = config[DOMAIN].get(CONF_SERVER_PORT, rem.SERVER_PORT) development = config[DOMAIN].get(CONF_DEVELOPMENT, "") == "1" server = HomeAssistantHTTPServer((server_host, server_port), RequestHandler, hass, api_password, development) hass.listen_once_event( ha.EVENT_HOMEASSISTANT_START, lambda event: threading.Thread(target=server.start, daemon=True).start()) # If no local api set, set one with known information if isinstance(hass, rem.HomeAssistant) and hass.local_api is None: hass.local_api = \ rem.API(util.get_local_ip(), api_password, server_port) return True
def _handle_post_api_event_forward(self, path_match, data): """ Handles adding an event forwarding target. """ try: host = data['host'] api_password = data['api_password'] except KeyError: self._message("No host or api_password received.", HTTP_BAD_REQUEST) return try: port = int(data['port']) if 'port' in data else None except ValueError: self._message( "Invalid value received for port", HTTP_UNPROCESSABLE_ENTITY) return if self.server.event_forwarder is None: self.server.event_forwarder = \ rem.EventForwarder(self.server.hass) api = rem.API(host, api_password, port) self.server.event_forwarder.connect(api) self._message("Event forwarding setup.")
def setup(hass, config): """Set up the HTTP API and debug interface.""" conf = config.get(DOMAIN, {}) api_password = util.convert(conf.get(CONF_API_PASSWORD), str) # If no server host is given, accept all incoming requests server_host = conf.get(CONF_SERVER_HOST, '0.0.0.0') server_port = conf.get(CONF_SERVER_PORT, SERVER_PORT) development = str(conf.get(CONF_DEVELOPMENT, "")) == "1" ssl_certificate = conf.get(CONF_SSL_CERTIFICATE) ssl_key = conf.get(CONF_SSL_KEY) try: server = HomeAssistantHTTPServer( (server_host, server_port), RequestHandler, hass, api_password, development, ssl_certificate, ssl_key) except OSError: # If address already in use _LOGGER.exception("Error setting up HTTP server") return False hass.bus.listen_once( ha.EVENT_HOMEASSISTANT_START, lambda event: threading.Thread(target=server.start, daemon=True, name='HTTP-server').start()) hass.http = server hass.config.api = rem.API(server_host if server_host != '0.0.0.0' else util.get_local_ip(), api_password, server_port, ssl_certificate is not None) return True
def setup(hass, config): """Set up the HTTP API and debug interface.""" _LOGGER.addFilter(HideSensitiveFilter(hass)) conf = config.get(DOMAIN, {}) api_password = util.convert(conf.get(CONF_API_PASSWORD), str) server_host = conf.get(CONF_SERVER_HOST, '0.0.0.0') server_port = conf.get(CONF_SERVER_PORT, SERVER_PORT) development = str(conf.get(CONF_DEVELOPMENT, "")) == "1" ssl_certificate = conf.get(CONF_SSL_CERTIFICATE) ssl_key = conf.get(CONF_SSL_KEY) cors_origins = conf.get(CONF_CORS_ORIGINS, []) server = HomeAssistantWSGI(hass, development=development, server_host=server_host, server_port=server_port, api_password=api_password, ssl_certificate=ssl_certificate, ssl_key=ssl_key, cors_origins=cors_origins) hass.bus.listen_once( ha.EVENT_HOMEASSISTANT_START, lambda event: threading.Thread( target=server.start, daemon=True, name='WSGI-server').start()) hass.wsgi = server hass.config.api = rem.API( server_host if server_host != '0.0.0.0' else util.get_local_ip(), api_password, server_port, ssl_certificate is not None) return True
def setup(hass, config=None): """ Sets up the HTTP API and debug interface. """ if config is None or DOMAIN not in config: config = {DOMAIN: {}} api_password = util.convert(config[DOMAIN].get(CONF_API_PASSWORD), str) no_password_set = api_password is None if no_password_set: api_password = util.get_random_string() # If no server host is given, accept all incoming requests server_host = config[DOMAIN].get(CONF_SERVER_HOST, '0.0.0.0') server_port = config[DOMAIN].get(CONF_SERVER_PORT, SERVER_PORT) development = str(config[DOMAIN].get(CONF_DEVELOPMENT, "")) == "1" server = HomeAssistantHTTPServer((server_host, server_port), RequestHandler, hass, api_password, development, no_password_set) hass.bus.listen_once( ha.EVENT_HOMEASSISTANT_START, lambda event: threading.Thread(target=server.start, daemon=True).start( )) hass.http = server hass.config.api = rem.API(util.get_local_ip(), api_password, server_port) return True
def connect(self): self.api = remote.API(self.host, api_password=self.password, port=self.port, use_ssl=self.use_ssl) print('Connecting to Home Assistant instance...') print(remote.validate_api(self.api))
def notification_loop(self): api = remote.API('brixpro.lan', haPass) while True: try: v = self.char_read_hnd(0x21) # objT = (v[1]<<8)+v[0] ambT = (v[3] << 8) + v[2] ambT = tosigned(ambT) c_tmpAmb = ambT / 128.0 f_tmpAmb = 9.0 / 5.0 * c_tmpAmb + 32 remote.set_state(api, 'sensor.bedroom_temp', new_state=f_tmpAmb, attributes={'unit_of_measurement': '°F'}) # targetT = calcTmpTarget(objT, ambT) # self.data['t006'] = targetT # print "T006 %.1f" % c_tmpAmb v = self.char_read_hnd(0x29) rawT = (v[1] << 8) + v[0] rawH = (v[3] << 8) + v[2] (t, rh) = calcHum(rawT, rawH) remote.set_state(api, 'sensor.bedroom_humidity', new_state=rh, attributes={'unit_of_measurement': '%'}) #print ("%s -- %.1f %.1f" % (time.strftime('%l:%M:%S%p %Z on %b %d, %Y'), f_tmpAmb, rh)) time.sleep(120) # save battery on sensortag? except pexpect.TIMEOUT: print("TIMEOUT exception!") break
def activate(self): """ Triggers on plugin activation You should delete it if you're not using it to override any default behaviour """ super(HomeAssistant, self).activate() self.api = remote.API(self.config['HASS_URL'], self.config['PASSWORD'])
def cycle(self): url = "http://pegasus.cs.moravian.edu:8080/api/wemo" # Enter url here api = remote.API('http://homeassistant.cs.moravian.edu:8123/states', 'raspberry') for i in range(3): remote.call_service(api, 'switch', 'turn_on') time.sleep(3) remote.call_service(api, 'switch', 'turn_off') time.sleep(3)
def async_setup(hass, config): """Set up the HTTP API and debug interface.""" conf = config.get(DOMAIN) if conf is None: conf = HTTP_SCHEMA({}) api_password = conf[CONF_API_PASSWORD] server_host = conf[CONF_SERVER_HOST] server_port = conf[CONF_SERVER_PORT] development = conf[CONF_DEVELOPMENT] == '1' ssl_certificate = conf[CONF_SSL_CERTIFICATE] ssl_key = conf[CONF_SSL_KEY] cors_origins = conf[CONF_CORS_ORIGINS] use_x_forwarded_for = conf[CONF_USE_X_FORWARDED_FOR] trusted_networks = conf[CONF_TRUSTED_NETWORKS] is_ban_enabled = conf[CONF_IP_BAN_ENABLED] login_threshold = conf[CONF_LOGIN_ATTEMPTS_THRESHOLD] if api_password is not None: logging.getLogger('aiohttp.access').addFilter( HideSensitiveDataFilter(api_password)) server = HomeAssistantWSGI( hass, development=development, server_host=server_host, server_port=server_port, api_password=api_password, ssl_certificate=ssl_certificate, ssl_key=ssl_key, cors_origins=cors_origins, use_x_forwarded_for=use_x_forwarded_for, trusted_networks=trusted_networks, login_threshold=login_threshold, is_ban_enabled=is_ban_enabled ) @asyncio.coroutine def stop_server(event): """Callback to stop the server.""" yield from server.stop() @asyncio.coroutine def start_server(event): """Callback to start the server.""" hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, stop_server) yield from server.start() hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, start_server) hass.http = server hass.config.api = rem.API(server_host if server_host != '0.0.0.0' else get_local_ip(), api_password, server_port, ssl_certificate is not None) return True
def test_validate_api(self): """Test Python API validate_api.""" self.assertEqual(remote.APIStatus.OK, remote.validate_api(master_api)) self.assertEqual( remote.APIStatus.INVALID_PASSWORD, remote.validate_api( remote.API("127.0.0.1", API_PASSWORD + "A", MASTER_PORT))) self.assertEqual(remote.APIStatus.CANNOT_CONNECT, remote.validate_api(broken_api))
def auth(self): status = True try: self.api = remote.API(self.metadata['host'], self.metadata['password'], self.metadata.get('port', 8123), self.metadata.get('use_ssl', False)) except HomeAssistantError as exception: logger.error(exception) status = False return status
def __init__(self, bot): self.bot = bot self.session = self.bot.http.session self.settings = dataIO.load_json(SETTINGS) if self.settings["ip"] == "": print("Cog error: hass, no IP found, please configure me!") if self.settings["api_key"] == "": print("Cog error: hass, no API Key found, please configure me!") global api global url api = remote.API(self.settings["ip"], self.settings["api_key"]) url = 'https://hass.justin-tech.com'
def ensure_slave_started(): """ Ensure a home assistant slave is started. """ ensure_homeassistant_started() if not HAHelper.slave: local_api = remote.API("127.0.0.1", API_PASSWORD, 8124) remote_api = remote.API("127.0.0.1", API_PASSWORD) slave = remote.HomeAssistant(remote_api, local_api) http.setup(slave, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: 8124}}) slave.start() # Give objects time to startup time.sleep(1) HAHelper.slave = slave return HAHelper.slave
def setup(hass, config): """Set up the HTTP API and debug interface.""" logging.getLogger('aiohttp.access').addFilter(HideSensitiveFilter(hass)) conf = config.get(DOMAIN, {}) api_password = util.convert(conf.get(CONF_API_PASSWORD), str) server_host = conf.get(CONF_SERVER_HOST, '0.0.0.0') server_port = conf.get(CONF_SERVER_PORT, SERVER_PORT) development = str(conf.get(CONF_DEVELOPMENT, '')) == '1' ssl_certificate = conf.get(CONF_SSL_CERTIFICATE) ssl_key = conf.get(CONF_SSL_KEY) cors_origins = conf.get(CONF_CORS_ORIGINS, []) use_x_forwarded_for = conf.get(CONF_USE_X_FORWARDED_FOR, False) trusted_networks = [ ip_network(trusted_network) for trusted_network in conf.get(CONF_TRUSTED_NETWORKS, []) ] server = HomeAssistantWSGI(hass, development=development, server_host=server_host, server_port=server_port, api_password=api_password, ssl_certificate=ssl_certificate, ssl_key=ssl_key, cors_origins=cors_origins, use_x_forwarded_for=use_x_forwarded_for, trusted_networks=trusted_networks) @asyncio.coroutine def stop_server(event): """Callback to stop the server.""" yield from server.stop() @asyncio.coroutine def start_server(event): """Callback to start the server.""" hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, stop_server) yield from server.start() hass.bus.listen_once(EVENT_HOMEASSISTANT_START, start_server) hass.http = server hass.config.api = rem.API( server_host if server_host != '0.0.0.0' else util.get_local_ip(), api_password, server_port, ssl_certificate is not None) return True
def structure_init(server, ha_ip, pwd): api = remote.API(ha_ip, pwd) cfg = remote.get_config(api) # e.g. make version property print(cfg) uri = "http://hassopcua.lvonwedel.net" idx = server.register_namespace(uri) # create state type for HASS types = server.get_node(ua.ObjectIds.BaseObjectType) object_type_to_derive_from = server.get_root_node().get_child( ["0:Types", "0:ObjectTypes", "0:BaseObjectType"]) ha_state_type = types.add_object_type(idx, "HAStateType") ha_state_type.add_variable(idx, "state", 1.0) # create objects objects = server.get_objects_node() loc_name = cfg['location_name'] loc_node = objects.add_folder(idx, loc_name) loc_node.add_property(idx, "location_name", loc_name) loc_node.add_property(idx, "elevation", cfg['elevation']) loc_node.add_property(idx, "latitiude", cfg['latitude']) loc_node.add_property(idx, "longitude", cfg['longitude']) loc_node.add_property(idx, "version", cfg['version']) entities = remote.get_states(api) for entity in entities: # create the node node = loc_node.add_object(idx, entity.entity_id, ha_state_type.nodeid) # set the value for the state child variable state = node.get_child('%d:state' % idx) state.set_value(entity.state) # node.set_attribute(ua.AttributeIds.DisplayName, entity.attributes['friendly_name']) for attr in entity.attributes.keys(): if attr in [ 'latitude', 'longitude', 'unit_of_measurement', 'friendly_name' ]: node.add_property(idx, attr, entity.attributes[attr]) return (idx, loc_name)
def cli(ctx, verbose, host, password, ssl, port): """A command line interface for Home Assistant.""" import requests ctx.verbose = verbose ctx.password = password ctx.ssl = ssl if host is not None: ctx.host = host if port is not None: ctx.port = port ctx.api = remote.API(ctx.host, ctx.password, ctx.port, ctx.ssl) if str(remote.validate_api(ctx.api)) == 'invalid_password': ctx.log("Your API password for %s was not provided or is wrong. " "Use '--password/-p'", ctx.host) sys.exit(1)
def __init__(self, hass, altitude, pressure_kpa, zones_sensors, connectors, refresh_interval, evolution_arrows_minutes, remote_api_conf): """Initialize Local File Camera component.""" self.hass = hass self._last_tile_generation = None self._delta_refresh = timedelta(seconds=refresh_interval) self._altitude = altitude self._pressure_kpa = pressure_kpa self.zones_sensors = zones_sensors self.colors_interior_zones = { k: next(POINT_COLORS) for k in sorted(self.zones_sensors[CONF_INTERIOR]) } self.connectors = connectors if evolution_arrows_minutes: len_deque = int( timedelta(minutes=evolution_arrows_minutes) / self._delta_refresh) else: len_deque = 1 self.points = deque([], maxlen=len_deque) self.svg_image_bytes = None self.delta_house = None self.open_house = None self._deadband = 0.5 # ºC self.sensor_attributes = {} # Remote access to sensors in other HA instance self.remote_api = None if remote_api_conf: from homeassistant import remote api = remote.API(remote_api_conf['base_url'], api_password=remote_api_conf.get('api_password'), port=remote_api_conf.get('port', 8123), use_ssl=remote_api_conf.get('use_ssl', False)) assert api.validate_api() self.remote_api = api # Chart regeneration if self.remote_api is not None: # No need to wait async_track_point_in_utc_time(self.hass, self.update_chart, now() + timedelta(seconds=10)) async_track_time_interval(self.hass, self.update_chart, self._delta_refresh)
def setup(hass, config): """Set up the HTTP API and debug interface.""" _LOGGER.addFilter(HideSensitiveFilter(hass)) conf = config.get(DOMAIN, {}) api_password = util.convert(conf.get(CONF_API_PASSWORD), str) server_host = conf.get(CONF_SERVER_HOST, '0.0.0.0') server_port = conf.get(CONF_SERVER_PORT, SERVER_PORT) development = str(conf.get(CONF_DEVELOPMENT, '')) == '1' ssl_certificate = conf.get(CONF_SSL_CERTIFICATE) ssl_key = conf.get(CONF_SSL_KEY) cors_origins = conf.get(CONF_CORS_ORIGINS, []) trusted_networks = [ ip_network(trusted_network) for trusted_network in conf.get(CONF_TRUSTED_NETWORKS, []) ] server = HomeAssistantWSGI(hass, development=development, server_host=server_host, server_port=server_port, api_password=api_password, ssl_certificate=ssl_certificate, ssl_key=ssl_key, cors_origins=cors_origins, trusted_networks=trusted_networks) def start_wsgi_server(event): """Start the WSGI server.""" server.start() hass.bus.listen_once(EVENT_HOMEASSISTANT_START, start_wsgi_server) def stop_wsgi_server(event): """Stop the WSGI server.""" server.stop() hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_wsgi_server) hass.wsgi = server hass.config.api = rem.API( server_host if server_host != '0.0.0.0' else util.get_local_ip(), api_password, server_port, ssl_certificate is not None) return True
def setUpModule(): # pylint: disable=invalid-name """Initalization of a Home Assistant server and Slave instance.""" global hass, slave, master_api hass = get_test_home_assistant() hass.bus.listen('test_event', lambda _: _) hass.states.set('test.test', 'a_state') bootstrap.setup_component( hass, http.DOMAIN, { http.DOMAIN: { http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: MASTER_PORT } }) bootstrap.setup_component(hass, 'api') hass.start() time.sleep(0.05) master_api = remote.API("127.0.0.1", API_PASSWORD, MASTER_PORT) # Start slave loop = asyncio.new_event_loop() # FIXME: should not be a daemon threading.Thread(name="SlaveThread", daemon=True, target=loop.run_forever).start() slave = remote.HomeAssistant(master_api, loop=loop) slave.config.config_dir = get_test_config_dir() slave.config.skip_pip = True bootstrap.setup_component( slave, http.DOMAIN, { http.DOMAIN: { http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: SLAVE_PORT } }) with patch.object(ha, 'async_create_timer', return_value=None): slave.start()
def setUpModule(): """Initialization of a Home Assistant server instance.""" global hass, master_api hass = get_test_home_assistant() hass.bus.listen('test_event', lambda _: _) hass.states.set('test.test', 'a_state') setup.setup_component( hass, http.DOMAIN, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: MASTER_PORT}}) setup.setup_component(hass, 'api') hass.start() master_api = remote.API('127.0.0.1', API_PASSWORD, MASTER_PORT)
def __init__(self, config, args): self.args = args self.nodes = Nodes() self.json = {'nodes': [], 'edges': []} self.haconf = homeassistant.config.load_yaml_config_file(config) self.directory = os.path.join(os.path.dirname(config), 'www') self.filename = 'z-wave-graph.json' # API connection necessities. api_password = None base_url = 'http://localhost' port = homeassistant.const.SERVER_PORT if self.haconf['http'] is not None and 'base_url' in self.haconf[ 'http']: base_url = self.haconf['http']['base_url'] if self.haconf['http'] is not None and 'api_password' in self.haconf[ 'http']: api_password = str(self.haconf['http']['api_password']) # If the base_url ends with a port, then strip it and set the port. # remote.API adds the default port if port= is not set. m = re.match(r'(^.*)(:(\d+))$', base_url) if m: base_url = m.group(1) port = m.group(3) self.api = remote.API(base_url, api_password, port=port) if remote.validate_api(self.api).value != 'ok': print("Error, unable to connect to the API: %s" % remote.validate_api(self.api)) sys.exit(1) self._get_entities() if self.args.debug: self.dump_nodes() self._build_dot()
def _handle_delete_api_event_forward(handler, path_match, data): """Handle deleting an event forwarding target.""" try: host = data['host'] except KeyError: handler.write_json_message("No host received.", HTTP_BAD_REQUEST) return try: port = int(data['port']) if 'port' in data else None except ValueError: handler.write_json_message( "Invalid value received for port", HTTP_UNPROCESSABLE_ENTITY) return if handler.server.event_forwarder is not None: api = rem.API(host, None, port) handler.server.event_forwarder.disconnect(api) handler.write_json_message("Event forwarding cancelled.")