def __init__(self): super().__init__() self.lights = Lights() self.weather = Weather() self.setObjectName('top-level') with open('ui.txt') as file: raw_ui = file.read() raw_ui += scale_template(forecast_day_template, 5) self.ui = UIBuilder(self, raw_ui) self.update_time() # set the time immediately self.light_buttons = {} self.create_lights_ui() self.weather_box = None self.update_weather_ui() self.weather_update_timeout = 1000 * 300 # five minutes, weather reports only update every 10 minutes self.light_refresh_timeout = 1000 * 10 self.interval(self.update_time, 1000) self.interval(self.rebuild_weather, self.weather_update_timeout) # poll every so often just in case the lights are changed elsewhere self.interval(self.refresh_lights, self.light_refresh_timeout) self.setStyleSheet(default_styles) self.setWindowTitle('Overseer Dashboard') self.show() # can be run using 'start_fullscreen.sh' for touch screens if 'fullscreen' in sys.argv: self.showFullScreen() else: self.setMinimumWidth(800) self.setMinimumHeight(480)
def test_add_trigger_to_scheduler(self): scheduler = Mock(wraps=BackgroundScheduler()) lights = Lights(scheduler=scheduler) state = True hour = 10 minute = 20 lights.add_trigger(state, hour, minute) scheduler.add_job.assert_called_with(func=ANY, args=[state, "trigger"], end_date=ANY, trigger="cron", id=None, hour=hour, minute=minute, day_of_week=None)
def __init__(self, modes): GPIO.setmode( GPIO.BCM) #set up to use gpio port numbers (instead of pin #s) self.buttons = Buttons() self.optos = Optos() self.lights = Lights() self.outlets = Outlets() self.sounds = Sounds() self.clock = Countdown(12) self.modes = modes self.last_time = time.localtime()
def test_add_trigger_to_scheduler_all_week(self): scheduler = Mock(wraps=BackgroundScheduler()) lights = Lights(scheduler=scheduler) state = True hour = 10 minute = 20 repeat_weekday = True repeat_weekend = True lights.add_trigger(state, hour, minute, repeat_weekday, repeat_weekend) scheduler.add_job.assert_called_with(func=ANY, args=[state, "trigger"], end_date=None, trigger="cron", id=None, hour=hour, minute=minute, day_of_week=Lights.weekdays + "," + Lights.weekends)
class LightsStoreTest(TestCase): def setUp(self): self.store = LightsStoreStub() self.lights = Lights(store=self.store) def test_should_add_trigger_to_store(self): self.store.add_trigger = MagicMock() self.lights.add_trigger(True, 10, 20) self.store.add_trigger.assert_called_with(ANY) def test_should_read_triggers_from_store(self): self.store.read_triggers = MagicMock() self.lights = Lights(store=self.store) self.store.read_triggers.assert_called_with() def test_should_remove_trigger_from_store(self): self.store.remove_trigger = MagicMock() self.lights.remove_trigger(job_id=TRIGGER.job_id) self.store.remove_trigger.assert_called_with(TRIGGER.job_id) def test_should_add_history_entry_to_store(self): self.store.add_entry = MagicMock() self.lights.set_state(True, "test") self.store.add_entry.assert_called_with(True, "test") def test_should_read_history_from_store(self): self.store.read_history = MagicMock() self.lights.get_history() self.store.read_history.assert_called_with()
def test_Slice_sliced_rval(self): ws = WS2812(1, 8) lights = Lights(ws) # Fill the lattice with a recognizable pattern for i, p in enumerate(tg(len(lights), 0)): lat = lights.lattice[i] for j, c in enumerate(p): lat[j] = c sls = lights[:2] # A sliced Lights has the correct length self.assertEqual(len(sls), 2) # A sliced Lights refers to the same lattice, not a copy self.assertIs(sls.lattice, lights.lattice) # A sliced Lights iterates over the correct lattice points self.assertEqual(list(sls), [bytearray(v) for v in tg(2,0)]) # A Lights can be sliced non-trivially and iterate over the # correct lattice points sls = lights[-2:-6:-2] self.assertEqual(len(sls), 2) self.assertEqual(list(sls), [bytearray(v) for v in [(18,19,20), (12,13,14)]])
def test_Slice_sliced_lval(self): ws = WS2812(1, 8) lights = Lights(ws) # Fill the lattice with a recognizable pattern for i, p in enumerate(tg(len(lights), 0)): lat = lights.lattice[i] for j, c in enumerate(p): lat[j] = c ref = lights.lattice[:] sls = lights[-2:-6:-2] # A Lights is indexable by an int for writing sls[1] = (10, 9, 8) self.assertEqual(list(sls), [bytearray(v) for v in [(18,19,20), (10,9,8)]]) # A Lights is indexable by a slice for writing sls[:] = [b'foo', b'bar'] self.assertEqual(list(sls), [bytearray(v) for v in [b'foo', b'bar']]) # The writes happen in the right place self.assertEqual([lights[6], lights[4]], [bytearray(v) for v in [b'foo', b'bar']]) # Other places don't get written self.assertEqual(list((i, lights[i]) for i in range(len(lights)) if i not in (6,4)), list((i, t) for i, t in enumerate(tg(len(lights), 0)) if i not in (6,4)))
def setUp(self): #logging.basicConfig(level=logging.INFO) self.ws = WS2812(1, 8) self.lights = lights = Lights(self.ws) # Fill the lattice with a recognizable pattern for i, c in enumerate(tg(len(lights), 0)): p = lights.lattice[i] for j, v in enumerate(c): p[j] = v
def main(): remote = Remote() lights = Lights() lights_on_command = LightsOnCommand(lights) lights_off_command = LightsOffCommand(lights) remote.set_command(lights_on_command) remote.pressButton() remote.set_command(lights_off_command) remote.pressButton()
class Controller: def __init__(self): self.root = "http://192.168.0.101/api/" self.usr = "******" self.login = self.root+ self.usr self.room = Lights(self.login) def get_scene(self, scene): filepath = './scenes/'+scene+'.json' with open(filepath) as json_file: settings = json.load(json_file) return settings def observe_lights(self): return self.room.updated_state() def control(self,scene): self.room.turn_on(scene)
def make_changes(preset, force=False): # Better handle this. if (os.path.exists('/tmp/pyhueapi.disable') and not force): sys.exit(0) lights = Lights() for i in preset: # print i tmp = lights.get(i['id']) # print tmp if None == tmp: continue data = i data.pop('id') try: # tmp._print() tmp.bulkSetState(data) # tmp._print() except Exception, e: print "[Utils] Failed: %s" % e.message pass
def setUp(self): #logging.basicConfig(level=logging.INFO) self.ws = WS2812(1, 8) self.lights = lights = Lights(self.ws) # Fill the lattice with a recognizable pattern for i, p in enumerate(tg(len(lights), 0)): lat = lights.lattice[i] for j, c in enumerate(p): lat[j] = c self.sls = lights[-2:-6:-2]
def setUp(self): #logging.basicConfig(level=logging.INFO) ws = self.ws = WS2812(1, 8) lights = self.lights = Lights(ws) # Fill the lattice with a recognizable pattern for i, p in enumerate(tg(len(lights), 0)): lat = lights.lattice[i] for j, c in enumerate(p): lat[j] = c # The leds are all clear self.assertEqual(sum(sum(c) for c in ws), 0) self.gear = Gear(lights=lights)
def __init__(self, write_fun=None, config={}): self.config = config if write_fun is None: @coroutine def write(self, *args): print(*args) self.write = write else: self.write = write_fun self.act_led = pyb.LED(3) self.err_led = pyb.LED(1) self.pkt_led = pyb.LED(2) self.pots = [0] * 4 self.percolator = \ Percolator(WS2812(spi_bus=config['leds'].get('spi'), led_count=config['leds'].get('qty'))) self.percolator.bingo = self.bingo self.ws_rings = WS2812(2, 2 * 7 + 45) self.ring_lights = Lights(self.ws_rings) self.feed_rollers = [ Jewel7(lights=self.ring_lights[0:7]), Jewel7(lights=self.ring_lights[7:14]) ] self.rr = RingRamp(lights=self.ring_lights[14:], circumference=60, \ bottom=7, \ g=-40.0, ball_check_fun = self.ball_check) # self.zap_balls = False self.set_brightness(31)
def acc(self): if not self.key_manager.check_key(self.key): # if the key is wrong returns error return self.build(self.error, "Wrong key") try: self.check_parameters() except Exception as e: return self.build(self.error, e.message) if self.get: pin = self.get_pin() if pin == 'A1': voltage = self.bridge.get(pin) return self.build(self.ok, str(get_celsius(voltage))) value = self.bridge.get(pin) return self.build(self.ok, str(value)) Lights(self.bridge).light_set(self.get_pin(), self.value) return self.build(self.ok, self.value)
def main(): lights = Lights(3) button = False voice_rec_thread = OrderingRecording(pyaudio.PyAudio(), menu_keywords) print('ready') while True: state = GPIO.input(BUTTON) if not state and not button: voice_rec_thread.start() button = True if state and button: lights.change(255, 0, 0) voice_rec_thread.stop() voice_rec_thread.join(5) voice_rec_thread = OrderingRecording(pyaudio.PyAudio(), menu_keywords) lights.change(0, 0, 0) button = False
from lights import Lights import os import time from threading import Thread from subprocess import call l = Lights(39) def fan(arg): call(["sudo", "./uhubctl", "-p", "2", "-a", arg]) def lightsPattern(): for i in range(2): if i%2 == 0: l.fillEach((100,0,0), 0.05) else: l.fillEach((0,0,100), 0.05) def lightsOff(): l.fillEach((0,0,0), 0.05) print("Options\n-----------------\n0. Fan Off\n1. Fan on\n2. Lights going\n3. Lights red\n4. Lights Blue\n5. Lights off\n---------------------\n") while True: option = input("Enter option: ") if option == '0': fan('0') elif option == '1': fan('1') elif option == '2':
from lights import RGB from lights import Lights import time colors = RGB(255, 255, 255) #Create an RGB object myLights = Lights(12, colors, 0.1, 0, 0) #Create a light object time.sleep(3) colors.setRed(255) colors.setGreen(0) colors.setBlue(0) myLights.setColor()
def test_should_read_triggers_from_store(self): self.store.read_triggers = MagicMock() self.lights = Lights(store=self.store) self.store.read_triggers.assert_called_with()
def __init__(self, mic): self.lights = Lights() self.therm = TempMonitor() self.door = Door(mic)
class Dashboard(QWidget): def __init__(self): super().__init__() self.lights = Lights() self.weather = Weather() self.setObjectName('top-level') with open('ui.txt') as file: raw_ui = file.read() raw_ui += scale_template(forecast_day_template, 5) self.ui = UIBuilder(self, raw_ui) self.update_time() # set the time immediately self.light_buttons = {} self.create_lights_ui() self.weather_box = None self.update_weather_ui() self.weather_update_timeout = 1000 * 300 # five minutes, weather reports only update every 10 minutes self.light_refresh_timeout = 1000 * 10 self.interval(self.update_time, 1000) self.interval(self.rebuild_weather, self.weather_update_timeout) # poll every so often just in case the lights are changed elsewhere self.interval(self.refresh_lights, self.light_refresh_timeout) self.setStyleSheet(default_styles) self.setWindowTitle('Overseer Dashboard') self.show() # can be run using 'start_fullscreen.sh' for touch screens if 'fullscreen' in sys.argv: self.showFullScreen() else: self.setMinimumWidth(800) self.setMinimumHeight(480) def refresh_lights(self): self.lights.refresh() self.set_light_on_status() def update_time(self): now = datetime.now() self.ui.set_text('clock-date', f'{pretty_weekday(now)} {pretty_date_only_str(now)}') self.ui.set_text('clock-time', pretty_time_str(now)) def interval(self, fn, ms): timer = QTimer(self) timer.timeout.connect(fn) timer.start(ms) def rebuild_weather(self): self.weather.refresh() self.update_weather_ui() def create_lights_ui(self): layout = self.ui.by_id('lights-box') def create_light_button(l): def on_click(): self.lights.toggle(l['id']) self.set_light_on_status() button = QPushButton(l['name']) self.light_buttons[l['id']] = button button.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Expanding) button.clicked.connect(on_click) layout.addWidget(button) lights = self.lights.get_lights() if len(lights) is 0: self.ui.show('lights-error') self.ui.hide('lights-container') else: self.ui.hide('lights-error') self.ui.show('lights-container') for light in lights: create_light_button(light) self.set_light_on_status() def set_light_on_status(self): for light in self.lights.get_lights(): button = self.light_buttons[light['id']] button.setProperty('light-on', light['on']) self.update_widget(button) def update_widget(self, widget): self.style().unpolish(widget) self.style().polish(widget) def update_weather_ui(self): def set_temp(id, weather_data, temp_attr): self.ui.set_text(id, weather_data[f'{temp_attr}-pretty']) self.ui.set_stylesheet( id, get_temp_color_stylesheet(weather_data[temp_attr])) self.ui.set_text('weather-box', f"Weather for {self.weather.get_location_name()}") today = self.weather.get_todays_forecast() self.ui.set_text('updated-time', f"last updated at {self.weather.get_updated_time()}") set_temp('current-temperature', today, 'temp') set_temp('today-low', today, 'low') set_temp('today-high', today, 'high') self.ui.set_text('current-conditions', f"{today['weather']}") self.ui.set_icon('current-icon', today['weather-icon']) self.connect_forecast_listener('today-details') if 'alerts' in today: self.ui.show('today-alert') alerts = today['alerts'] self.ui.set_text( 'today-alert', f'{len(alerts)} active alert{"s" if len(alerts) > 1 else ""}') self.connect_alert_listener('today-alert', alerts) else: self.ui.hide('today-alert') def set_precip_message(label_id, message): if message is not None: self.ui.set_text(label_id, message) self.ui.show(label_id) else: self.ui.hide(label_id) rain_msg, snow_msg = self.weather.get_upcoming_precip_message() set_precip_message('upcoming-rain', rain_msg) set_precip_message('upcoming-snow', snow_msg) # skip the current day for i, day in enumerate(self.weather.get_days()[1:]): self.ui.set_text(f'forecast-day-{i}', day['dt-pretty']) self.ui.set_text(f'forecast-day-{i}-conditions', day['weather']) self.connect_forecast_listener(f'forecast-day-{i}-details', day) set_temp(f'forecast-day-{i}-low', day, 'low') set_temp(f'forecast-day-{i}-high', day, 'high') self.ui.set_icon(f'forecast-day-{i}-icon', day['weather-icon'], 50) for precip in ['rain', 'snow']: label_id = f'forecast-day-{i}-precip-{precip}' set_precip_message(label_id, day[precip]) def connect_alert_listener(self, id, alerts): def show_weather_alert(): layout = QVBoxLayout() for alert in alerts: header = QLabel(alert['headline']) header.setWordWrap(True) header.setProperty('header', True) layout.addWidget(header) layout.addWidget(QLabel(f"{alert['description']}")) box = ScrollMessageBox('Weather Alert', layout) self.ui.on_click(id, show_weather_alert) def connect_forecast_listener(self, id, day=None): def show_forecast(): periods = self.weather.get_periods_by_day(day) # if it's late in the day for the current day, we might not have any more information, show an alert instead if periods is None: alert = Alert( 'No more data', "It is late and there is no more available data for today." ) return layout = QHBoxLayout() ui = UIBuilder( layout, scale_template(periods_detail_template, len(periods))) for i, period in enumerate(periods): ui.set_text(f'time-{i}', pretty_time_str_short(period['dt'])) ui.set_icon(f'icon-{i}', period['weather-icon'], 75) temp_id = f'temp-{i}' ui.set_text(temp_id, period['temp-pretty']) ui.by_id(temp_id).setStyleSheet( get_temp_color_stylesheet(period['temp'])) ui.set_text(f'conditions-{i}', period['weather']) def show_precip(precip_type): precip = period[precip_type] precip_id = f'{precip_type}-{i}' if precip is not None: ui.set_text(precip_id, precip) else: ui.hide(precip_id) for precip_type in ['rain', 'snow']: show_precip(precip_type) pretty_day = day["dt-pretty"] if day is not None else "Today" dlg = ScrollMessageBox(f'Weather for {pretty_day}', layout) self.ui.on_click(id, show_forecast)
def __init__(self, ip): Lights.__init__(self, ip) self.nations = flags.FRAMES.keys() self.send('australia')
def ready(self): monome.Page.ready(self) Lights.ready(self)
def setUp(self): self.lights = Lights()
def __init__(self, manager): monome.Page.__init__(self, manager) Lights.__init__(self)
def ready(self): monome.Section.ready(self) Lights.ready(self)
def test_Slice(self): ws = WS2812(1, 8) lights = Lights(ws) self.assertEqual(len(lights), 8)
def __init__(self, app): monome.Page.__init__(self, app) Lights.__init__(self)
def getRequestResponse(self): if self.command == RequestHandler.HEARTBEAT: self.setData({ 'serverType': self.player.getServerType(), 'irRemote': config.USES_IR_REMOTE }) elif self.command == RequestHandler.PLAY_PAUSE: self.player.playPause() elif self.command == RequestHandler.NEXT: self.player.next() elif self.command == RequestHandler.PREVIOUS: self.player.previous() elif self.command == RequestHandler.SEEK_FORWARD: self.player.seekForward() elif self.command == RequestHandler.SEEK_BACKWARD: self.player.seekBackward() elif self.command == RequestHandler.SKIP_TITLE_SEQUENCE: self.player.skipTitleSequence() elif self.command == RequestHandler.VOLUME_UP: self.player.volumeUp() elif self.command == RequestHandler.VOLUME_DOWN: self.player.volumeDown() elif self.command == RequestHandler.FULLSCREEN: self.player.fullScreen() elif self.command == RequestHandler.TOGGLE_CONTROLS: self.player.toggleControls() elif self.command == RequestHandler.RANDOM_SETTINGS: self.setData(Shows(self.mountPoint).getShowCategories()) elif self.command == RequestHandler.ALL_SHOWS: self.setData(Shows(self.mountPoint).getAllShows()) elif self.command == RequestHandler.LAST_PLAYLIST: playlist = self.player.getPlaylist() playlistExists = playlist.playlistExists() if playlistExists: self.player.playPlaylist() self.setSuccess(playlistExists) self.setData(playlist.getFormattedShows()) elif self.command == RequestHandler.CURRENT_PLAYLIST or self.command == RequestHandler.CURRENT_PLAYLIST_SELECTION: playlist = self.player.getPlaylist() self.setSuccess(playlist.playlistExists()) self.setData(playlist.getFormattedShows()) elif self.command == RequestHandler.RANDOM: filePaths = self.getRandom() if self.success and filePaths: self.playRandom(filePaths) elif self.command == RequestHandler.FOREIGN_RANDOM: if 'localhost' == config.CONNECTION_TYPE: filePaths = self.getRandom() if self.success and filePaths: self.setData(filePaths) else: self.setSuccess(False) elif self.command == RequestHandler.BROWSE: self.browse() elif self.command == RequestHandler.PLAY: self.play(Player.PLAY) elif self.command == RequestHandler.ENQUEUE: self.play(Player.ENQUEUE) elif self.command == RequestHandler.INSERT_AT: self.insertAt() elif self.command == RequestHandler.PLAY_AT: self.playAt() elif self.command == RequestHandler.FOREIGN_UPDATE_PLAY_TIME: if 'localhost' == config.CONNECTION_TYPE: self.__checkAndUpdateFilePaths() else: self.setSuccess(False) elif self.command == RequestHandler.QUIT: self.player.quit() #TV commands, handled seperatly elif self.command == RequestHandler.TV_VOLUME_UP: if not config.USES_IR_REMOTE: raise CommandNotSupported( 'No support for IR commands on this server') IRRemote.sendCommand(IRRemote.VOLUME_UP) elif self.command == RequestHandler.TV_VOLUME_DOWN: if not config.USES_IR_REMOTE: raise CommandNotSupported( 'No support for IR commands on this server') IRRemote.sendCommand(IRRemote.VOLUME_DOWN) elif self.command == RequestHandler.TV_MUTE: if not config.USES_IR_REMOTE: raise CommandNotSupported( 'No support for IR commands on this server') IRRemote.sendCommand(IRRemote.MUTE) elif self.command == RequestHandler.TV_POWER: if not config.USES_IR_REMOTE: raise CommandNotSupported( 'No support for IR commands on this server') IRRemote.sendCommand(IRRemote.POWER) elif self.command == RequestHandler.TV_SOURCE: if not config.USES_IR_REMOTE: raise CommandNotSupported( 'No support for IR commands on this server') IRRemote.sendCommand(IRRemote.SOURCE) #BT commads, handled seperatly elif self.command == RequestHandler.HARDWARE_BUTTON_PRESS: if not config.IS_BLUETOOTH_SERVER: raise CommandNotSupported( 'Cannot send Bluetooth commands on a non Bluetooth server') BluetoothServer.QUEUE.put(BluetoothServer.HARDWARE_BUTTON_PRESS) elif self.command == RequestHandler.HARDWARE_BUTTON_PRESS_AND_HOLD: if not config.IS_BLUETOOTH_SERVER: raise CommandNotSupported( 'Cannot send Bluetooth commands on a non Bluetooth server') BluetoothServer.QUEUE.put( BluetoothServer.HARDWARE_BUTTON_PRESS_AND_HOLD) elif self.command == RequestHandler.LIGHTS_RGB: if not config.IS_BLUETOOTH_SERVER: raise CommandNotSupported( 'Cannot send Bluetooth commands on a non Bluetooth server') lights = Lights(self.postVars.get('red', 0), self.postVars.get('green', 0), self.postVars.get('blue', 0)) command = lights.buildString() if not command: raise CommandNotSupported( 'All colors must be between 255 and 0') queueCommand = BluetoothServer.LIGHTS_RGB + command BluetoothServer.QUEUE.put(queueCommand) #If we have made it this far, we don't know how to handle this command as we should just raise our exception else: raise InvalidRequest('Unknown request command') return self.respond()
class LightsSchedulerTest(TestCase): def setUp(self): self.lights = Lights() def test_starts_scheduler(self): mock = Mock() Lights(scheduler=mock) mock.start.assert_called_with() def test_add_trigger_to_scheduler(self): scheduler = Mock(wraps=BackgroundScheduler()) lights = Lights(scheduler=scheduler) state = True hour = 10 minute = 20 lights.add_trigger(state, hour, minute) scheduler.add_job.assert_called_with(func=ANY, args=[state, "trigger"], end_date=ANY, trigger="cron", id=None, hour=hour, minute=minute, day_of_week=None) def test_add_trigger_to_scheduler_weekday(self): scheduler = Mock(wraps=BackgroundScheduler()) lights = Lights(scheduler=scheduler) state = True hour = 10 minute = 20 repeat_weekday = True lights.add_trigger(state, hour, minute, repeat_weekday=repeat_weekday) scheduler.add_job.assert_called_with(func=ANY, args=[state, "trigger"], end_date=None, trigger="cron", id=None, hour=hour, minute=minute, day_of_week=Lights.weekdays) def test_add_trigger_to_scheduler_weekend(self): scheduler = Mock(wraps=BackgroundScheduler()) lights = Lights(scheduler=scheduler) state = True hour = 10 minute = 20 repeat_weekend = True lights.add_trigger(state, hour, minute, repeat_weekend=repeat_weekend) scheduler.add_job.assert_called_with(func=ANY, args=[state, "trigger"], end_date=None, trigger="cron", id=None, hour=hour, minute=minute, day_of_week=Lights.weekends) def test_add_trigger_to_scheduler_all_week(self): scheduler = Mock(wraps=BackgroundScheduler()) lights = Lights(scheduler=scheduler) state = True hour = 10 minute = 20 repeat_weekday = True repeat_weekend = True lights.add_trigger(state, hour, minute, repeat_weekday, repeat_weekend) scheduler.add_job.assert_called_with(func=ANY, args=[state, "trigger"], end_date=None, trigger="cron", id=None, hour=hour, minute=minute, day_of_week=Lights.weekdays + "," + Lights.weekends) def test_add_trigger_and_get_job(self): state = True hour = 10 minute = 20 self.lights.add_trigger(state, hour, minute) jobs = self.lights._scheduler.get_jobs() assert_that(jobs, has_length(1)) def test_add_triggers_and_get_jobs(self): num = 5 for i in range(num): self.lights.add_trigger(True, 10, 20) jobs = self.lights._scheduler.get_jobs() assert_that(jobs, has_length(num)) triggers = self.lights.get_triggers() assert_that(triggers, has_length(num)) def test_add_and_get_trigger(self): state = True hour = 10 minute = 20 now = int(time()) self.lights.add_trigger(state, hour, minute) job_id = self.lights._scheduler.get_jobs()[0].id triggers = self.lights.get_triggers() assert_that(triggers, has_length(1)) trigger = triggers[0] assert_that(trigger.job_id, is_(job_id)) assert_that(trigger.state, is_(state)) assert_that(trigger.hour, is_(hour)) assert_that(trigger.minute, is_(minute)) assert_that(trigger.next_run_time, is_(greater_than(now))) assert_that(trigger.repeat_weekday, is_(False)) assert_that(trigger.repeat_weekend, is_(False)) def test_add_and_get_trigger_with_update_run_time(self): next_run_time = datetime(year=2010, month=1, day=1, tzinfo=utc) expected_next_run_time = int(next_run_time.timestamp()) self.lights.add_trigger(True, 10, 20) job_id = self.lights._scheduler.get_jobs()[0].id job = Mock() job.id = job_id job.next_run_time = next_run_time self.lights._scheduler.get_jobs = MagicMock(return_value=[job]) triggers = self.lights.get_triggers() assert_that(triggers, has_length(1)) trigger = triggers[0] assert_that(trigger.next_run_time, is_(expected_next_run_time)) def test_add_no_repeat_has_end_date(self): self.lights.add_trigger(True, 10, 20) job = self.lights._scheduler.get_jobs()[0] assert_that(job.trigger.end_date, is_(not_none())) def test_remove_finished_jobs_from_trigger(self): self.lights.add_trigger(True, 10, 20) self.lights.add_trigger(True, 10, 20) jobs = self.lights._scheduler.get_jobs() removed_job_id = jobs[0].id keep_job_id = jobs[1].id self.lights._scheduler.remove_job(removed_job_id) jobs = self.lights._scheduler.get_jobs() assert_that(jobs, has_length(1)) triggers = self.lights.get_triggers() assert_that(triggers, has_length(1)) trigger = triggers[0] assert_that(trigger.job_id, is_(keep_job_id)) def test_delete_trigger_from_triggers(self): self.lights.add_trigger(True, 10, 20) jobs = self.lights._scheduler.get_jobs() job_id = jobs[0].id triggers = self.lights.get_triggers() assert_that(triggers, has_length(1)) self.lights.remove_trigger(job_id) triggers = self.lights.get_triggers() assert_that(triggers, is_(empty())) def test_delete_job_from_scheduler(self): self.lights.add_trigger(True, 10, 20) jobs = self.lights._scheduler.get_jobs() job_id = jobs[0].id assert_that(jobs, has_length(1)) self.lights.remove_trigger(job_id) jobs = self.lights._scheduler.get_jobs() assert_that(jobs, is_(empty()))
def handle(self, data): now = "=TIMESTAMP_TO_DATE(INDIRECT(\"A\" & ROW()))" data.append(now) print('send the following to the sheet: %s' % data) self.sheet.append_values(data) # enable garbage collection gc.enable() print('garbage collection threshold: ' + str(gc.threshold())) # load configuration for a file config = Config('main.conf', 'key.json') # initialize an interface to LEDs lights = Lights(config.get('wifi_led_pid'), config.get('error_led_pid'), config.get('high_co2_led_pin')) lights.off() # create an instance of ServiceAccount class # which then is going to be used to obtain an OAuth2 token # for writing data to a sheet sa = ServiceAccount() sa.email(config.get('google_service_account_email')) sa.scope('https://www.googleapis.com/auth/spreadsheets') sa.private_rsa_key(config.private_rsa_key()) # create an instance of Spreadsheet which is used to write data to a sheet spreadsheet = Spreadsheet() spreadsheet.set_service_account(sa) spreadsheet.set_id(config.get('google_sheet_id')) spreadsheet.set_range('A:A')
def _spin_hardware_channels(self): self.lights = Lights(self.light_input_queue, self.light_output_queue) self.motor = Lights(self.light_input_queue, self.light_output_queue) self.mfcs = Lights(self.light_input_queue, self.light_output_queue)
logging.warning('** - lights off time: ' + str(lightsOffDateTime)) job = self.scheduler.add_job(self.lightsOff, misfire_grace_time=86400, trigger='date', next_run_time=str(lightsOffDateTime), args=[config, Dusk(config)]) logging.warning("scheduled job added: %s" % job) def lightsOff(self, config, dusk): # Turn the lights off logging.warning('********** Lights Off *************') self.lights.switch('one', False) # Look up tomorrow's dusktime tomorrow = date.today() + timedelta(days=1) tomorrowDuskDateTime = dusk.getDuskTime(tomorrow) logging.warning('** - dusk time at: ' + str(tomorrowDuskDateTime)) # Schedule to turn the lights on at the next dusktime job = self.scheduler.add_job(self.lightsOn, misfire_grace_time=86400, trigger='date', next_run_time=str(tomorrowDuskDateTime), args=[config]) logging.warning("scheduled job added: %s" % job) if __name__ == "__main__": LightSchedule(Lights(Config())).main(Config(), Dusk(Config()))
def setUp(self): self.store = LightsStoreStub() self.lights = Lights(store=self.store)
'start': { 'color_x': 0, 'color_y': 0, 'level': 100, 'devices': [DEVICE] }, 'start': { 'color_x': 0, 'color_y': 0, 'level': 100, 'devices': [DEVICE] } } } light_api = Lights() def find_setting(ev): wordlist = ev['description'].split() smallcaps = map(lambda x: x.lower(), wordlist) for word in smallcaps: if word in KEYWORD_SETTING_MAP: return KEYWORD_SETTING_MAP[word] return DEFAULT_SETTING def call_light(lc, dt): ''' lc light call
def getRequestResponse(self): if self.command == RequestHandler.HEARTBEAT: self.setData({'serverType' : self.player.getServerType(), 'irRemote' : config.USES_IR_REMOTE}) elif self.command == RequestHandler.PLAY_PAUSE: self.player.playPause() elif self.command == RequestHandler.NEXT: self.player.next() elif self.command == RequestHandler.PREVIOUS: self.player.previous() elif self.command == RequestHandler.SEEK_FORWARD: self.player.seekForward() elif self.command == RequestHandler.SEEK_BACKWARD: self.player.seekBackward() elif self.command == RequestHandler.SKIP_TITLE_SEQUENCE: self.player.skipTitleSequence() elif self.command == RequestHandler.VOLUME_UP: self.player.volumeUp() elif self.command == RequestHandler.VOLUME_DOWN: self.player.volumeDown() elif self.command == RequestHandler.FULLSCREEN: self.player.fullScreen() elif self.command == RequestHandler.TOGGLE_CONTROLS: self.player.toggleControls() elif self.command == RequestHandler.RANDOM_SETTINGS: self.setData(Shows(self.mountPoint).getShowCategories()) elif self.command == RequestHandler.ALL_SHOWS: self.setData(Shows(self.mountPoint).getAllShows()) elif self.command == RequestHandler.LAST_PLAYLIST: playlist = self.player.getPlaylist() playlistExists = playlist.playlistExists() if playlistExists: self.player.playPlaylist() self.setSuccess(playlistExists) self.setData(playlist.getFormattedShows()) elif self.command == RequestHandler.CURRENT_PLAYLIST or self.command == RequestHandler.CURRENT_PLAYLIST_SELECTION: playlist = self.player.getPlaylist() self.setSuccess(playlist.playlistExists()) self.setData(playlist.getFormattedShows()) elif self.command == RequestHandler.RANDOM: filePaths = self.getRandom() if self.success and filePaths: self.playRandom(filePaths) elif self.command == RequestHandler.FOREIGN_RANDOM: if 'localhost' == config.CONNECTION_TYPE: filePaths = self.getRandom() if self.success and filePaths: self.setData(filePaths) else: self.setSuccess(False) elif self.command == RequestHandler.BROWSE: self.browse() elif self.command == RequestHandler.PLAY: self.play(Player.PLAY) elif self.command == RequestHandler.ENQUEUE: self.play(Player.ENQUEUE) elif self.command == RequestHandler.INSERT_AT: self.insertAt() elif self.command == RequestHandler.PLAY_AT: self.playAt() elif self.command == RequestHandler.FOREIGN_UPDATE_PLAY_TIME: if 'localhost' == config.CONNECTION_TYPE: self.__checkAndUpdateFilePaths() else: self.setSuccess(False) elif self.command == RequestHandler.QUIT: self.player.quit() #TV commands, handled seperatly elif self.command == RequestHandler.TV_VOLUME_UP: if not config.USES_IR_REMOTE: raise CommandNotSupported('No support for IR commands on this server') IRRemote.sendCommand(IRRemote.VOLUME_UP) elif self.command == RequestHandler.TV_VOLUME_DOWN: if not config.USES_IR_REMOTE: raise CommandNotSupported('No support for IR commands on this server') IRRemote.sendCommand(IRRemote.VOLUME_DOWN) elif self.command == RequestHandler.TV_MUTE: if not config.USES_IR_REMOTE: raise CommandNotSupported('No support for IR commands on this server') IRRemote.sendCommand(IRRemote.MUTE) elif self.command == RequestHandler.TV_POWER: if not config.USES_IR_REMOTE: raise CommandNotSupported('No support for IR commands on this server') IRRemote.sendCommand(IRRemote.POWER) elif self.command == RequestHandler.TV_SOURCE: if not config.USES_IR_REMOTE: raise CommandNotSupported('No support for IR commands on this server') IRRemote.sendCommand(IRRemote.SOURCE) #BT commads, handled seperatly elif self.command == RequestHandler.HARDWARE_BUTTON_PRESS: if not config.IS_BLUETOOTH_SERVER: raise CommandNotSupported('Cannot send Bluetooth commands on a non Bluetooth server') BluetoothServer.QUEUE.put(BluetoothServer.HARDWARE_BUTTON_PRESS) elif self.command == RequestHandler.HARDWARE_BUTTON_PRESS_AND_HOLD: if not config.IS_BLUETOOTH_SERVER: raise CommandNotSupported('Cannot send Bluetooth commands on a non Bluetooth server') BluetoothServer.QUEUE.put(BluetoothServer.HARDWARE_BUTTON_PRESS_AND_HOLD) elif self.command == RequestHandler.LIGHTS_RGB: if not config.IS_BLUETOOTH_SERVER: raise CommandNotSupported('Cannot send Bluetooth commands on a non Bluetooth server') lights = Lights(self.postVars.get('red', 0), self.postVars.get('green', 0), self.postVars.get('blue', 0)) command = lights.buildString() if not command: raise CommandNotSupported('All colors must be between 255 and 0') queueCommand = BluetoothServer.LIGHTS_RGB+command BluetoothServer.QUEUE.put(queueCommand) #If we have made it this far, we don't know how to handle this command as we should just raise our exception else: raise InvalidRequest('Unknown request command') return self.respond()
class InterfaceManager(object): def __init__(self, use_fictrac=True, use_pi=True, use_logging=True): self.use_fictrac = use_fictrac self.use_pi = use_pi self.use_logging = use_logging self.running = False self.outgoing_interfaces = [] self.light_input_queue = queue.Queue() self.light_output_queue = queue.Queue() def _spin_incoming_interface(self): if self.use_fictrac: self.incoming_interface = FicTracInterface() else: self.incoming_interface = ReplayInterface() self.incoming_interface.connect() def _spin_outgoing_interfaces(self): if self.use_pi: self.outgoing_interfaces.append(RaspberryPiInterface()) if self.use_logging: self.outgoing_interfaces.append(LoggingInterface()) [interface.connect() for interface in self.outgoing_interfaces] def _spin_hardware_channels(self): self.lights = Lights(self.light_input_queue, self.light_output_queue) self.motor = Lights(self.light_input_queue, self.light_output_queue) self.mfcs = Lights(self.light_input_queue, self.light_output_queue) def run_interfaces(self): if self.incoming_interface.initialized == False: sys.exit() self.running = True a = time.time() try: while self.running: ret = self.incoming_interface.read() output = self.incoming_interface.clean() if ret == False: break self.light_input_queue.put( [output[i] for i in self.lights.selection_mask]) self.lights.read_and_wrote.wait() updated = self.light_output_queue.get() self.lights.reset() [ interface.write(data) for interface in self.outgoing_interfaces ] except KeyboardInterrupt: sys.exit() def safe_shutdown(self): light_controller.safe_shutdown() motor_controller.safe_shutdown() mfc_controller.safe_shutdown()
from lights import Lights lights = Lights() for i in range(100): lights.iterate() print(lights.count_on())
from lights import Lights lights = Lights() for corner in ((0, 0), (0, 99), (99, 0), (99, 99)): lights.state[corner] = 'X' for i in range(100): lights.iterate() print(lights.count_on())
def __init__(self, splitter, size, offset): monome.Section.__init__(self, splitter, size, offset) Lights.__init__(self)
#!/usr/bin/env python import logging from button import Button from lights import Lights from open_ocd import OpenOCD from tel_con import TelCon if __name__ == '__main__': logging.basicConfig(format="%(asctime)s:" + logging.BASIC_FORMAT) logger = logging.getLogger() logger.setLevel(logging.DEBUG) while True: try: with Lights(logger.getChild('lights')) as light: with Button(logger.getChild('button')) as button: button.wait_for_button_press() light.busy() try: with OpenOCD(logger.getChild('openocd')) as openOCD: with TelCon(logger.getChild('telcon')) as telcon: telcon.halt() telcon.erase() telcon.load() light.busyOff() light.success() except Exception: logging.warn("Provisioning failed") light.busyOff() light.failed() except Exception:
class LightsStateTest(TestCase): def setUp(self): self.lights = Lights() def test_state_starts_as_false(self): assert_that(self.lights.get_state(), is_(False)) def test_set_and_return_state(self): self.lights.set_state(True, "test") assert_that(self.lights.get_state(), is_(True)) def test_toggle_flips_state(self): assert_that(self.lights.get_state(), is_(False)) self.lights.toggle("test") assert_that(self.lights.get_state(), is_(True)) def test_set_state_does_not_change_if_less_than_bounce_duration(self): self.lights.set_state(True, "test") assert_that(self.lights.get_state(), is_(True)) self.lights.set_state(False, "test") assert_that(self.lights.get_state(), is_(True)) def test_set_state_changes_if_more_than_bounce_duration(self): with freeze_time(datetime.now()) as curr_time: self.lights.set_state(True, "test") assert_that(self.lights.get_state(), is_(True)) curr_time.tick(delta=timedelta(seconds=90)) self.lights.set_state(False, "test") assert_that(self.lights.get_state(), is_(False)) def test_toggle_does_not_change_if_less_than_bounce_duration(self): self.lights.toggle("test") assert_that(self.lights.get_state(), is_(True)) self.lights.toggle("test") assert_that(self.lights.get_state(), is_(True)) def test_toggle_changes_if_more_than_bounce_duration(self): with freeze_time(datetime.now()) as curr_time: self.lights.toggle("test") assert_that(self.lights.get_state(), is_(True)) curr_time.tick(delta=timedelta(seconds=90)) self.lights.toggle("test") assert_that(self.lights.get_state(), is_(False))