def test_setting_rising(self): """ Test retrieving sun setting and rising. """ # Compare it with the real data self.hass.config.latitude = '32.87336' self.hass.config.longitude = '117.22743' sun.setup(self.hass, None) observer = ephem.Observer() observer.lat = '32.87336' # pylint: disable=assigning-non-slot observer.long = '117.22743' # pylint: disable=assigning-non-slot utc_now = dt_util.utcnow() body_sun = ephem.Sun() # pylint: disable=no-member next_rising_dt = observer.next_rising( body_sun, start=utc_now).datetime().replace(tzinfo=dt_util.UTC) next_setting_dt = observer.next_setting( body_sun, start=utc_now).datetime().replace(tzinfo=dt_util.UTC) # Home Assistant strips out microseconds # strip it out of the datetime objects next_rising_dt = dt_util.strip_microseconds(next_rising_dt) next_setting_dt = dt_util.strip_microseconds(next_setting_dt) self.assertEqual(next_rising_dt, sun.next_rising_utc(self.hass)) self.assertEqual(next_setting_dt, sun.next_setting_utc(self.hass)) # Point it at a state without the proper attributes self.hass.states.set(sun.ENTITY_ID, sun.STATE_ABOVE_HORIZON) self.assertIsNone(sun.next_rising(self.hass)) self.assertIsNone(sun.next_setting(self.hass)) # Point it at a non-existing state self.assertIsNone(sun.next_rising(self.hass, 'non.existing')) self.assertIsNone(sun.next_setting(self.hass, 'non.existing'))
def test_setting_rising(self): """ Test retrieving sun setting and rising. """ # Compare it with the real data self.hass.config.latitude = '32.87336' self.hass.config.longitude = '117.22743' sun.setup(self.hass, None) observer = ephem.Observer() observer.lat = '32.87336' # pylint: disable=assigning-non-slot observer.long = '117.22743' # pylint: disable=assigning-non-slot utc_now = dt_util.utcnow() body_sun = ephem.Sun() # pylint: disable=no-member next_rising_dt = observer.next_rising( body_sun, start=utc_now).datetime().replace(tzinfo=dt_util.UTC) next_setting_dt = observer.next_setting( body_sun, start=utc_now).datetime().replace(tzinfo=dt_util.UTC) # Home Assistant strips out microseconds # strip it out of the datetime objects next_rising_dt = dt_util.strip_microseconds(next_rising_dt) next_setting_dt = dt_util.strip_microseconds(next_setting_dt) self.assertEqual(next_rising_dt, sun.next_rising_utc(self.hass)) self.assertEqual(next_setting_dt, sun.next_setting_utc(self.hass)) # Point it at a state without the proper attributes self.hass.states.set(sun.ENTITY_ID, sun.STATE_ABOVE_HORIZON) self.assertIsNone(sun.next_rising(self.hass)) self.assertIsNone(sun.next_setting(self.hass)) # Point it at a non-existing state self.assertIsNone(sun.next_rising(self.hass, 'non.existing')) self.assertIsNone(sun.next_setting(self.hass, 'non.existing'))
def test_setup(self): """ Test Sun setup with empty and wrong configs. """ self.assertFalse(sun.setup(self.hass, {})) self.assertFalse(sun.setup(self.hass, {sun.DOMAIN: {}})) self.assertFalse(sun.setup( self.hass, {ha.DOMAIN: {CONF_LATITUDE: '32.87336'}})) self.assertFalse(sun.setup( self.hass, {ha.DOMAIN: {CONF_LONGITUDE: '117.22743'}})) self.assertFalse(sun.setup( self.hass, {ha.DOMAIN: {CONF_LATITUDE: 'hello'}})) self.assertFalse(sun.setup( self.hass, {ha.DOMAIN: {CONF_LONGITUDE: 'how are you'}})) self.assertFalse(sun.setup( self.hass, {ha.DOMAIN: { CONF_LATITUDE: 'wrong', CONF_LONGITUDE: '117.22743' }})) self.assertFalse(sun.setup( self.hass, {ha.DOMAIN: { CONF_LATITUDE: '32.87336', CONF_LONGITUDE: 'wrong' }})) # Test with correct config self.assertTrue(sun.setup( self.hass, {ha.DOMAIN: { CONF_LATITUDE: '32.87336', CONF_LONGITUDE: '117.22743' }}))
def test_track_sunrise(self): """Test track the sunrise.""" latitude = 32.87336 longitude = 117.22743 # Setup sun component self.hass.config.latitude = latitude self.hass.config.longitude = longitude sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) # Get next sunrise/sunset astral = Astral() utc_now = dt_util.utcnow() mod = -1 while True: next_rising = (astral.sunrise_utc(utc_now + timedelta(days=mod), latitude, longitude)) if next_rising > utc_now: break mod += 1 # Track sunrise runs = [] unsub = track_sunrise(self.hass, lambda: runs.append(1)) offset_runs = [] offset = timedelta(minutes=30) unsub2 = track_sunrise(self.hass, lambda: offset_runs.append(1), offset) # run tests self._send_time_changed(next_rising - offset) self.hass.pool.block_till_done() self.assertEqual(0, len(runs)) self.assertEqual(0, len(offset_runs)) self._send_time_changed(next_rising) self.hass.pool.block_till_done() self.assertEqual(1, len(runs)) self.assertEqual(0, len(offset_runs)) self._send_time_changed(next_rising + offset) self.hass.pool.block_till_done() self.assertEqual(2, len(runs)) self.assertEqual(1, len(offset_runs)) unsub() unsub2() self._send_time_changed(next_rising + offset) self.hass.pool.block_till_done() self.assertEqual(2, len(runs)) self.assertEqual(1, len(offset_runs))
def test_track_sunrise(self): """Test track the sunrise.""" latitude = 32.87336 longitude = 117.22743 # Setup sun component self.hass.config.latitude = latitude self.hass.config.longitude = longitude sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) # Get next sunrise/sunset astral = Astral() utc_now = dt_util.utcnow() mod = -1 while True: next_rising = (astral.sunrise_utc(utc_now + timedelta(days=mod), latitude, longitude)) if next_rising > utc_now: break mod += 1 # Track sunrise runs = [] unsub = track_sunrise(self.hass, lambda: runs.append(1)) offset_runs = [] offset = timedelta(minutes=30) unsub2 = track_sunrise(self.hass, lambda: offset_runs.append(1), offset) # run tests self._send_time_changed(next_rising - offset) self.hass.pool.block_till_done() self.assertEqual(0, len(runs)) self.assertEqual(0, len(offset_runs)) self._send_time_changed(next_rising) self.hass.pool.block_till_done() self.assertEqual(1, len(runs)) self.assertEqual(0, len(offset_runs)) self._send_time_changed(next_rising + offset) self.hass.pool.block_till_done() self.assertEqual(2, len(runs)) self.assertEqual(1, len(offset_runs)) unsub() unsub2() self._send_time_changed(next_rising + offset) self.hass.pool.block_till_done() self.assertEqual(2, len(runs)) self.assertEqual(1, len(offset_runs))
def setUp(self): # pylint: disable=invalid-name self.hass = get_test_home_assistant() self.scanner = loader.get_component('device_tracker.test').get_scanner( None, None) self.scanner.reset() self.scanner.come_home('DEV1') loader.get_component('light.test').init() self.assertTrue( device_tracker.setup( self.hass, {device_tracker.DOMAIN: { CONF_PLATFORM: 'test' }})) self.assertTrue( light.setup(self.hass, {light.DOMAIN: { CONF_PLATFORM: 'test' }})) self.assertTrue( sun.setup(self.hass, {sun.DOMAIN: { sun.CONF_ELEVATION: 0 }}))
def test_state_change(self): """ Test if the state changes at next setting/rising. """ self.assertTrue( sun.setup( self.hass, { ha.DOMAIN: { CONF_LATITUDE: '32.87336', CONF_LONGITUDE: '117.22743' } })) if sun.is_on(self.hass): test_state = sun.STATE_BELOW_HORIZON test_time = sun.next_setting(self.hass) else: test_state = sun.STATE_ABOVE_HORIZON test_time = sun.next_rising(self.hass) self.assertIsNotNone(test_time) self.hass.bus.fire(ha.EVENT_TIME_CHANGED, {ha.ATTR_NOW: test_time + dt.timedelta(seconds=5)}) self.hass.pool.block_till_done() self.assertEqual(test_state, self.hass.states.get(sun.ENTITY_ID).state)
def test_track_sunset(self): """ Test track sunset decorator """ latitude = 32.87336 longitude = 117.22743 # setup sun component self.hass.config.latitude = latitude self.hass.config.longitude = longitude sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) # get next sunrise/sunset astral = Astral() utc_now = dt_util.utcnow() mod = -1 while True: next_setting = astral.sunset_utc(utc_now + timedelta(days=mod), latitude, longitude) if next_setting > utc_now: break mod += 1 # use decorator runs = [] decor = track_sunset() decor(lambda x: runs.append(1)) offset_runs = [] offset = timedelta(minutes=30) decor = track_sunset(offset) decor(lambda x: offset_runs.append(1)) # run tests self._send_time_changed(next_setting - offset) self.hass.pool.block_till_done() self.assertEqual(0, len(runs)) self.assertEqual(0, len(offset_runs)) self._send_time_changed(next_setting) self.hass.pool.block_till_done() self.assertEqual(1, len(runs)) self.assertEqual(0, len(offset_runs)) self._send_time_changed(next_setting + offset) self.hass.pool.block_till_done() self.assertEqual(2, len(runs)) self.assertEqual(1, len(offset_runs))
def test_state_change(self): """Test if the state changes at next setting/rising.""" sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) if sun.is_on(self.hass): test_state = sun.STATE_BELOW_HORIZON test_time = sun.next_setting(self.hass) else: test_state = sun.STATE_ABOVE_HORIZON test_time = sun.next_rising(self.hass) self.assertIsNotNone(test_time) self.hass.bus.fire(ha.EVENT_TIME_CHANGED, {ha.ATTR_NOW: test_time + timedelta(seconds=5)}) self.hass.pool.block_till_done() self.assertEqual(test_state, self.hass.states.get(sun.ENTITY_ID).state)
def test_state_change(self): """Test if the state changes at next setting/rising.""" sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) if sun.is_on(self.hass): test_state = sun.STATE_BELOW_HORIZON test_time = sun.next_setting(self.hass) else: test_state = sun.STATE_ABOVE_HORIZON test_time = sun.next_rising(self.hass) self.assertIsNotNone(test_time) self.hass.bus.fire(ha.EVENT_TIME_CHANGED, {ha.ATTR_NOW: test_time + timedelta(seconds=5)}) self.hass.pool.block_till_done() self.assertEqual(test_state, self.hass.states.get(sun.ENTITY_ID).state)
def test_setup(self): """ Test Sun setup with empty and wrong configs. """ self.assertFalse(sun.setup(self.hass, {})) self.assertFalse(sun.setup(self.hass, {sun.DOMAIN: {}})) self.assertFalse( sun.setup(self.hass, {ha.DOMAIN: { ha.CONF_LATITUDE: '32.87336' }})) self.assertFalse( sun.setup(self.hass, {ha.DOMAIN: { ha.CONF_LONGITUDE: '117.22743' }})) self.assertFalse( sun.setup(self.hass, {ha.DOMAIN: { ha.CONF_LATITUDE: 'hello' }})) self.assertFalse( sun.setup(self.hass, {ha.DOMAIN: { ha.CONF_LONGITUDE: 'how are you' }})) self.assertFalse( sun.setup( self.hass, { ha.DOMAIN: { ha.CONF_LATITUDE: 'wrong', ha.CONF_LONGITUDE: '117.22743' } })) self.assertFalse( sun.setup( self.hass, { ha.DOMAIN: { ha.CONF_LATITUDE: '32.87336', ha.CONF_LONGITUDE: 'wrong' } })) # Test with correct config self.assertTrue( sun.setup( self.hass, { ha.DOMAIN: { ha.CONF_LATITUDE: '32.87336', ha.CONF_LONGITUDE: '117.22743' } }))
def test_state_change(self): """ Test if the state changes at next setting/rising. """ self.hass.config.latitude = "32.87336" self.hass.config.longitude = "117.22743" sun.setup(self.hass, {}) if sun.is_on(self.hass): test_state = sun.STATE_BELOW_HORIZON test_time = sun.next_setting(self.hass) else: test_state = sun.STATE_ABOVE_HORIZON test_time = sun.next_rising(self.hass) self.assertIsNotNone(test_time) self.hass.bus.fire(ha.EVENT_TIME_CHANGED, {ha.ATTR_NOW: test_time + timedelta(seconds=5)}) self.hass.pool.block_till_done() self.assertEqual(test_state, self.hass.states.get(sun.ENTITY_ID).state)
def setUp(self): # pylint: disable=invalid-name self.hass = get_test_home_assistant() self.scanner = loader.get_component( 'device_tracker.test').get_scanner(None, None) self.scanner.reset() self.scanner.come_home('DEV1') loader.get_component('light.test').init() device_tracker.setup(self.hass, { device_tracker.DOMAIN: {CONF_PLATFORM: 'test'} }) light.setup(self.hass, { light.DOMAIN: {CONF_PLATFORM: 'test'} }) sun.setup(self.hass, {})
def test_state_change(self): """ Test if the state changes at next setting/rising. """ self.hass.config.latitude = '32.87336' self.hass.config.longitude = '117.22743' sun.setup(self.hass, {}) if sun.is_on(self.hass): test_state = sun.STATE_BELOW_HORIZON test_time = sun.next_setting(self.hass) else: test_state = sun.STATE_ABOVE_HORIZON test_time = sun.next_rising(self.hass) self.assertIsNotNone(test_time) self.hass.bus.fire(ha.EVENT_TIME_CHANGED, {ha.ATTR_NOW: test_time + timedelta(seconds=5)}) self.hass.pool.block_till_done() self.assertEqual(test_state, self.hass.states.get(sun.ENTITY_ID).state)
def test_setting_rising(self): """Test retrieving sun setting and rising.""" latitude = 32.87336 longitude = 117.22743 # Compare it with the real data self.hass.config.latitude = latitude self.hass.config.longitude = longitude sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) astral = Astral() utc_now = dt_util.utcnow() mod = -1 while True: next_rising = (astral.sunrise_utc(utc_now + timedelta(days=mod), latitude, longitude)) if next_rising > utc_now: break mod += 1 mod = -1 while True: next_setting = (astral.sunset_utc(utc_now + timedelta(days=mod), latitude, longitude)) if next_setting > utc_now: break mod += 1 self.assertEqual(next_rising, sun.next_rising_utc(self.hass)) self.assertEqual(next_setting, sun.next_setting_utc(self.hass)) # Point it at a state without the proper attributes self.hass.states.set(sun.ENTITY_ID, sun.STATE_ABOVE_HORIZON) self.assertIsNone(sun.next_rising(self.hass)) self.assertIsNone(sun.next_setting(self.hass)) # Point it at a non-existing state self.assertIsNone(sun.next_rising(self.hass, 'non.existing')) self.assertIsNone(sun.next_setting(self.hass, 'non.existing'))
def test_setting_rising(self): """ Test retrieving sun setting and rising. """ latitude = 32.87336 longitude = 117.22743 # Compare it with the real data self.hass.config.latitude = latitude self.hass.config.longitude = longitude sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) astral = Astral() utc_now = dt_util.utcnow() mod = -1 while True: next_rising = (astral.sunrise_utc(utc_now + timedelta(days=mod), latitude, longitude)) if next_rising > utc_now: break mod += 1 mod = -1 while True: next_setting = (astral.sunset_utc(utc_now + timedelta(days=mod), latitude, longitude)) if next_setting > utc_now: break mod += 1 self.assertEqual(next_rising, sun.next_rising_utc(self.hass)) self.assertEqual(next_setting, sun.next_setting_utc(self.hass)) # Point it at a state without the proper attributes self.hass.states.set(sun.ENTITY_ID, sun.STATE_ABOVE_HORIZON) self.assertIsNone(sun.next_rising(self.hass)) self.assertIsNone(sun.next_setting(self.hass)) # Point it at a non-existing state self.assertIsNone(sun.next_rising(self.hass, 'non.existing')) self.assertIsNone(sun.next_setting(self.hass, 'non.existing'))
def test_setting_rising(self): """Test retrieving sun setting and rising.""" sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) from astral import Astral astral = Astral() utc_now = dt_util.utcnow() latitude = self.hass.config.latitude longitude = self.hass.config.longitude mod = -1 while True: next_rising = astral.sunrise_utc(utc_now + timedelta(days=mod), latitude, longitude) if next_rising > utc_now: break mod += 1 mod = -1 while True: next_setting = astral.sunset_utc(utc_now + timedelta(days=mod), latitude, longitude) if next_setting > utc_now: break mod += 1 self.assertEqual(next_rising, sun.next_rising_utc(self.hass)) self.assertEqual(next_setting, sun.next_setting_utc(self.hass)) # Point it at a state without the proper attributes self.hass.states.set(sun.ENTITY_ID, sun.STATE_ABOVE_HORIZON) self.assertIsNone(sun.next_rising(self.hass)) self.assertIsNone(sun.next_setting(self.hass)) # Point it at a non-existing state self.assertIsNone(sun.next_rising(self.hass, "non.existing")) self.assertIsNone(sun.next_setting(self.hass, "non.existing"))
def test_norway_in_june(self): """Test location in Norway where the sun doesn't set in summer.""" self.hass.config.latitude = 69.6 self.hass.config.longitude = 18.8 june = datetime(2016, 6, 1, tzinfo=dt_util.UTC) with patch("homeassistant.helpers.condition.dt_util.utcnow", return_value=june): assert sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) state = self.hass.states.get(sun.ENTITY_ID) assert state is not None assert sun.next_rising_utc(self.hass) == datetime(2016, 7, 25, 23, 38, 21, tzinfo=dt_util.UTC) assert sun.next_setting_utc(self.hass) == datetime(2016, 7, 26, 22, 4, 18, tzinfo=dt_util.UTC)
def test_norway_in_june(self): """Test location in Norway where the sun doesn't set in summer.""" self.hass.config.latitude = 69.6 self.hass.config.longitude = 18.8 june = datetime(2016, 6, 1, tzinfo=dt_util.UTC) with patch('homeassistant.helpers.condition.dt_util.utcnow', return_value=june): assert sun.setup(self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}) state = self.hass.states.get(sun.ENTITY_ID) assert state is not None assert sun.next_rising_utc(self.hass) == \ datetime(2016, 7, 25, 23, 38, 21, tzinfo=dt_util.UTC) assert sun.next_setting_utc(self.hass) == \ datetime(2016, 7, 26, 22, 4, 18, tzinfo=dt_util.UTC)
def test_setting_rising(self): """ Test retrieving sun setting and rising. """ # Compare it with the real data self.assertTrue( sun.setup( self.hass, { ha.DOMAIN: { CONF_LATITUDE: '32.87336', CONF_LONGITUDE: '117.22743' } })) observer = ephem.Observer() observer.lat = '32.87336' # pylint: disable=assigning-non-slot observer.long = '117.22743' # pylint: disable=assigning-non-slot utc_now = dt.datetime.utcnow() body_sun = ephem.Sun() # pylint: disable=no-member next_rising_dt = ephem.localtime( observer.next_rising(body_sun, start=utc_now)) next_setting_dt = ephem.localtime( observer.next_setting(body_sun, start=utc_now)) # Home Assistant strips out microseconds # strip it out of the datetime objects next_rising_dt = next_rising_dt - dt.timedelta( microseconds=next_rising_dt.microsecond) next_setting_dt = next_setting_dt - dt.timedelta( microseconds=next_setting_dt.microsecond) self.assertEqual(next_rising_dt, sun.next_rising(self.hass)) self.assertEqual(next_setting_dt, sun.next_setting(self.hass)) # Point it at a state without the proper attributes self.hass.states.set(sun.ENTITY_ID, sun.STATE_ABOVE_HORIZON) self.assertIsNone(sun.next_rising(self.hass)) self.assertIsNone(sun.next_setting(self.hass)) # Point it at a non-existing state self.assertIsNone(sun.next_rising(self.hass, 'non.existing')) self.assertIsNone(sun.next_setting(self.hass, 'non.existing'))
def test_setting_rising(self): """ Test retrieving sun setting and rising. """ # Compare it with the real data self.assertTrue(sun.setup( self.hass, {ha.DOMAIN: { CONF_LATITUDE: '32.87336', CONF_LONGITUDE: '117.22743' }})) observer = ephem.Observer() observer.lat = '32.87336' # pylint: disable=assigning-non-slot observer.long = '117.22743' # pylint: disable=assigning-non-slot utc_now = dt.datetime.utcnow() body_sun = ephem.Sun() # pylint: disable=no-member next_rising_dt = ephem.localtime( observer.next_rising(body_sun, start=utc_now)) next_setting_dt = ephem.localtime( observer.next_setting(body_sun, start=utc_now)) # Home Assistant strips out microseconds # strip it out of the datetime objects next_rising_dt = next_rising_dt - dt.timedelta( microseconds=next_rising_dt.microsecond) next_setting_dt = next_setting_dt - dt.timedelta( microseconds=next_setting_dt.microsecond) self.assertEqual(next_rising_dt, sun.next_rising(self.hass)) self.assertEqual(next_setting_dt, sun.next_setting(self.hass)) # Point it at a state without the proper attributes self.hass.states.set(sun.ENTITY_ID, sun.STATE_ABOVE_HORIZON) self.assertIsNone(sun.next_rising(self.hass)) self.assertIsNone(sun.next_setting(self.hass)) # Point it at a non-existing state self.assertIsNone(sun.next_rising(self.hass, 'non.existing')) self.assertIsNone(sun.next_setting(self.hass, 'non.existing'))
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() event_decorators.HASS = self.hass self.scanner = loader.get_component( 'device_tracker.test').get_scanner(None, None) self.scanner.reset() self.scanner.come_home('DEV1') loader.get_component('light.test').init() self.assertTrue(device_tracker.setup(self.hass, { device_tracker.DOMAIN: {CONF_PLATFORM: 'test'} })) self.assertTrue(light.setup(self.hass, { light.DOMAIN: {CONF_PLATFORM: 'test'} })) self.assertTrue(sun.setup( self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}))
def test_state_change(self): """ Test if the state changes at next setting/rising. """ self.assertTrue(sun.setup( self.hass, {ha.DOMAIN: { CONF_LATITUDE: '32.87336', CONF_LONGITUDE: '117.22743' }})) if sun.is_on(self.hass): test_state = sun.STATE_BELOW_HORIZON test_time = sun.next_setting(self.hass) else: test_state = sun.STATE_ABOVE_HORIZON test_time = sun.next_rising(self.hass) self.assertIsNotNone(test_time) self.hass.bus.fire(ha.EVENT_TIME_CHANGED, {ha.ATTR_NOW: test_time + dt.timedelta(seconds=5)}) self.hass._pool.block_till_done() self.assertEqual(test_state, self.hass.states.get(sun.ENTITY_ID).state)
def from_config_file(config_path): """ Starts home assistant with all possible functionality based on a config file. """ statusses = [] # Read config config = ConfigParser.SafeConfigParser() config.read(config_path) # Init core bus = ha.Bus() statemachine = ha.StateMachine(bus) # Device scanner if config.has_option('tomato', 'host') and \ config.has_option('tomato', 'username') and \ config.has_option('tomato', 'password') and \ config.has_option('tomato', 'http_id'): device_scanner = device.TomatoDeviceScanner( config.get('tomato', 'host'), config.get('tomato', 'username'), config.get('tomato', 'password'), config.get('tomato', 'http_id')) statusses.append(("Device Scanner - Tomato", device_scanner.success_init)) elif config.has_option('netgear', 'host') and \ config.has_option('netgear', 'username') and \ config.has_option('netgear', 'password'): device_scanner = device.NetgearDeviceScanner( config.get('netgear', 'host'), config.get('netgear', 'username'), config.get('netgear', 'password')) statusses.append(("Device Scanner - Netgear", device_scanner.success_init)) else: device_scanner = None if device_scanner and not device_scanner.success_init: device_scanner = None # Device Tracker if device_scanner: device.DeviceTracker(bus, statemachine, device_scanner) statusses.append(("Device Tracker", True)) # Sun tracker if config.has_option("common", "latitude") and \ config.has_option("common", "longitude"): statusses.append(("Weather - Ephem", sun.setup( bus, statemachine, config.get("common", "latitude"), config.get("common", "longitude")))) # Chromecast if config.has_option("chromecast", "host"): chromecast_started = chromecast.setup(bus, statemachine, config.get("chromecast", "host")) statusses.append(("Chromecast", chromecast_started)) else: chromecast_started = False # Light control if config.has_section("hue"): if config.has_option("hue", "host"): light_control = light.HueLightControl(config.get("hue", "host")) else: light_control = light.HueLightControl() statusses.append(("Light Control - Hue", light_control.success_init)) else: light_control = None # Light trigger if light_control: light.setup(bus, statemachine, light_control) statusses.append(("Light Trigger", device_sun_light_trigger.setup( bus, statemachine))) if config.has_option("downloader", "download_dir"): statusses.append(("Downloader", downloader.setup( bus, config.get("downloader", "download_dir")))) # Currently only works with Chromecast or Light_Control if chromecast_started or light_control: statusses.append(("General", general.setup(bus, statemachine))) statusses.append(("Browser", browser.setup(bus))) statusses.append(("Media Buttons", keyboard.setup(bus))) # Init HTTP interface if config.has_option("httpinterface", "api_password"): httpinterface.HTTPInterface( bus, statemachine, config.get("httpinterface", "api_password")) statusses.append(("HTTPInterface", True)) logger = logging.getLogger(__name__) for component, success_init in statusses: status = "initialized" if success_init else "Failed to initialize" logger.info("{}: {}".format(component, status)) ha.start_home_assistant(bus)