def start_test_player(): log_fmt = ( "%(asctime)s %(levelname)s:%(name)s %(filename)s:%(lineno)d " "%(message)s") logging.basicConfig(level=logging.DEBUG, format=log_fmt) service = PlayoutService() schedule = playlist.Schedule() v = schedule.new_program() v.set_program(1758, clock.now() - datetime.timedelta(0, 5), title="First", playback_offset=10, playback_duration=10.0) schedule.add(v) for n in range(1): delta = datetime.timedelta(0, 6+(n)*10.0) v = schedule.new_program() v.set_program(1758, clock.now() + delta, title="No %i" % n, playback_offset=30+60*n, playback_duration=9.0) print "Added %i @ %s" % (n, v.program_start) schedule.add(v) player = Playout(service) player.set_schedule(schedule) # import playoutweb # playoutweb.start_web(None, playout_service=service, playout=player, # schedule=schedule, port=8888) reactor.callLater(4.0, player.show_still) reactor.callLater(7.0, player.cancel_still) return player
def feed_unit(self, unit_id): # maybe it should take a clock. """Feeds a unit from the silo, most they can be fed is every 60 days""" # A scient eats their composition's worth of stones in 2 months. # (60 days) # every two months from when the unit was born, discount the inventory # the unit's value. # Two weeks without food a unit dies. def feed(unit, lnow): self.silo.get(unit.comp) unit.fed_on = now() unit = self.units[unit_id] lnow = now() if unit.fed_on is None: feed(unit, lnow) else: delta = lnow - unit.fed_on dsecs = delta.total_seconds() if dsecs > (self.field.clock.duration['day'] * 60): if dsecs < (self.field.clock.duration['day'] * 72): feed(unit, lnow) else: self.bury_unit(unit_id) else: pass # unit already fed.
def onMessage(self, frame, binary): cmd = frame[:frame.find(":")] arg = frame[frame.find(":")+2:] logging.info("Command from web: %s" % (repr(frame))) if cmd == "display-still": self.playout.show_still("stills/"+arg) elif cmd == "cancel-still": self.playout.cancel_still() elif cmd == "play-mediaid": argl = arg.split(' ') media_id = int(argl[0]) offset = float(argl[1]) duration = float(argl[2]) p = playlist.Program() p.set_program(media_id, program_start=clock.now(), playback_offset=offset, playback_duration=duration, title="%i direct play media" % media_id) # TODO: Move to service ? self.playout.cue_program(p) elif cmd == "resume-playback": # TODO: Rename to resume schedule? self.playout.resume_playback() self.playout.start_schedule() elif cmd == "resume-current-program": self.playout.resume_current_program() elif cmd == "clear-next-program": self.playout.set_next_program(None) self.playout.stop_schedule() elif cmd == "set-next-program-from-schedule": self.playout.start_schedule() elif cmd == "reload-schedule": self.schedule.update_from_pg_cache(days=14) self.service.on_set_schedule(None) self.playout.start_schedule()
def on_playback_started(self, program): if not program: program = self.schedule.new_program() program.set_program(-1, program_start=clock.now(), title="*** Dead Air ***", playback_duration=float("inf")) self.sendMessage("next: %s" % program.json()) logging.warning("playing '*** Dead Air ***' sent to webbrowser") else: self.sendMessage("playing: %s" % program.json())
def on_idle(self): time_until_next = float("inf") if self.next_program: time_until_next = self.next_program.seconds_until_playback() # The rules. use_jukebox = configuration.jukebox use_jukebox &= time_until_next > (120+IDENT_LENGTH) use_jukebox &= self.random_provider.enough_room(time_until_next) if use_jukebox: loop_length = 12.0 PAUSE_LENGTH = IDENT_LENGTH+loop_length logging.info("Pause before jukebox: %.1fs" % PAUSE_LENGTH) program = self.schedule.new_program() program.set_program(-1, program_start=clock.now(), playback_duration=loop_length, title="Jukebox pause screen", filename=LOOP_FILENAME, loop=True) self.cue_program(program) self.on_end_call_stack.append(self.play_ident) self.on_end_call_stack.append(self.play_jukebox) elif time_until_next >= 12+IDENT_LENGTH: logging.info("Pause idle: %.1fs" % time_until_next) PAUSE_LENGTH = time_until_next program = self.schedule.new_program() program.set_program(-1, program_start=clock.now(), playback_duration=time_until_next-IDENT_LENGTH, title="Pause screen", filename=LOOP_FILENAME, loop=True) self.cue_program(program) self.on_end_call_stack.append(self.play_ident) else: logging.info("Short idle: %.1fs" % time_until_next) # Show pausescreen program = self.schedule.new_program() t = None if self.next_program: t = self.next_program.seconds_until_playback() program.set_program(-1, program_start=clock.now(), playback_duration=t, title="Pause screen", filename=LOOP_FILENAME, loop=True) #self.cue_program(program) # TODO: Doesn't handle looping self.player.pause_screen() self.playing_program = program self.service.on_playback_started(program)
def seconds_until_end(self): duration = self.playback_duration if not duration: duration = self.get(duration) if not duration: raise Exception, "No duration given for video %i" % self.media_id dt = self.program_start - clock.now() return dt.seconds + dt.microseconds / 1e6 + duration
def on_set_next_program(self, program): if not program: # TODO: Set next-start, if possible, to duration-progress program = self.schedule.new_program() program.set_program(-1, program_start=clock.now(), title="*** Dead Air ***", playback_duration=float("inf")) self.sendMessage("next: %s" % program.json()) logging.warning("next-program '*** Dead Air ***' sent to webbrowser") else: self.sendMessage("next: %s" % program.json())
def update_from_pg_cache(self, date=None, days=7): "Testing in pgsched" if not date: date = clock.now().date() programs = [] day_loaded = [] for day in range(days): l = pgsched.get_schedule_by_date(date + datetime.timedelta(days=day)) this_date = date + datetime.timedelta(days=day) if not l: day_loaded.append((this_date, False)) continue day_loaded.append((this_date, True)) for d in l: program = self.new_program() program.set_program( media_id=d["broadcast_location"], program_start=d["starttime"], playback_offset=0.0, playback_duration=d["duration"] / 1000.0, title=d["name"], # unused: # endtime, video_id, header, schedule_reagion.... data=d, ) programs.append(program) # Just print continously what days weren't loaded start = None last = None err = [] while day_loaded: day, loaded = day_loaded.pop(0) if (not start) and (not loaded): # We have hit a first failure start = day last = day elif start and (not loaded): # The failure-streak lasts until today at least last = day if (start and loaded) or (not day_loaded and start): # But it ended today if start == last: # It was a single day err.append(str(start)) else: # It was a streak err.append("%s - %s" % (str(start), str(last))) if err: logging.warning("Failed to update plans: %s" % ",".join(err)) # Reconstruct playlist if programs: self.programs = [] for program in programs: self.add(program) else: logging.warning("Cache empty")
def play_ident(self): logging.info("Ident playback start") program = self.schedule.new_program() program.set_program( media_id=-1, program_start=clock.now(), playback_duration=IDENT_LENGTH, title="Frikanalen Vignett", filename=IDENT_FILENAME) self.cue_program(program)
def render_GET(self, request): if not request.args.get("date"): date = clock.now().date() else: y, m, d = request.args["date"][0].split('-') date = datetime.date(year=int(y), month=int(m), day=int(d)) l = self.schedule.get_programs_by_date(date, as_dict=True) d = {"date": "%i-%i-%i" % (date.year, date.month, date.day), "schedule": l} s = json.dumps(d) return s
def get_programs_by_date(self, date=None, as_dict=False): if not date: date = clock.now().date() l = [] for program in self.programs: if program.program_start.date() == date: if as_dict: l.append(program.to_dict()) else: l.append(program) return l
def get_next_program(self): now = clock.now() next = None for program in self.programs: if program.program_start <= now: # program already started continue if not next or next.program_start > program.program_start: # program is closer to now next = program return next
def feed_units(self): """Attempts to feed units. check happens every game day.""" # 1. feed scients first. # 2. feed nescients. # should not happen when field is embattled. n = now() for unit in self.units: d = n - unit.fed_on dsecs = d.total_seconds() if dsecs > (self.field.clock.duration['day'] * 60): self.feed_unit(unit.uid)
def get_current_program(self): now = clock.now() last = None for program in self.programs: if program.program_start <= now: # program already started last = program if program.playback_duration and (program.seconds_since_playback() >= program.playback_duration): last = None if last and program.program_start >= now: break return last
def play_jukebox(self): logging.info("Jukebox playback start") program = self.schedule.new_program() limit = 90*60 # 90 minutes long programs max if self.next_program: limit = min(limit, self.next_program.seconds_until_playback()) video = self.random_provider.get_random_video(limit) program.set_program( media_id=video["media_id"], program_start=clock.now(), playback_duration=video["duration"], title=video["name"]) self.cue_program(program)
def headers(self, url, params=None, method=urlfetch.GET, other_headers = None): oauth_headers = {'oauth_nonce': nonce(), 'oauth_callback': self.callback_url, 'oauth_signature_method': "HMAC-SHA1", 'oauth_timestamp': str(clock.timestamp(clock.now())), 'oauth_consumer_key': self.consumer_key, 'oauth_version': '1.0'} if other_headers: oauth_headers.update(other_headers) if self.access_token: oauth_headers['oauth_token'] = self.access_token oauth_headers['oauth_signature'] = self.sign(url, method, params, oauth_headers) oauth_headers['realm'] = '' return {'Authorization': 'OAuth ' + ', '.join('%s="%s"' % (key, _encode(value)) for key, value in oauth_headers.items())}
def onOpen(self): if not self.service: return self.service.add_observer(self) # Will get a lot of info from here self.sendMessage("time: %s" % clock.now().ctime())
def seconds_since_playback(self): dt = clock.now() - self.program_start return dt.seconds + dt.microseconds / 1e6
def seconds_until_playback(self): dt = self.program_start - clock.now() return dt.seconds + dt.microseconds / 1e6
def feed(unit, lnow): self.silo.get(unit.comp) unit.fed_on = now()
def on_set_schedule(self, schedule): self.sendMessage("schedule-updated: %s" % clock.now().ctime())
# ---- UPDATE TIMERS ---- # if t - timers[0] >= 1.0 / cfg["clock_hz"]: timers[0] = t # ---- TIME OF DAY BRIGHTNESS ---- # now = datetime.now() # fade is lowest at 3am, highest 3pm fade = (abs(now.hour + now.minute / 60 + now.second / 3600 - 3) % 24) / 24.0 display.brightness(0.10 + 0.9*fade) # ---- CLOCK ---- # if cfg["fade_clock"] and is_playing: c = Image.blend(c_last, blank, cfg["clock_blend_alpha"]) else: c = clock.now(cfg["clock_font"], size=cfg["clock_size"], tint=cfg["clock_color"]) c = Image.blend(c_last, c, cfg["afterimage_alpha"]) if t - timers[1] >= cfg["scheme_switch_timer"]: timers[1] = t SCHEME = next(SCHEMES) if t - timers[2] >= cfg["cava_config_timer"]: timers[2] = t cava.reload_config(cava_ps) cfg = configure() if t - timers[3] >= 1.0 / cfg["scroll_speed"]: timers[3] = t # ---- COMPOSE AND RENDER ---- #
import os import os.path import tensorflow as tf import clock from IPython.display import clear_output # Set Up GPU from tensorflow.python.client import device_lib print(device_lib.list_local_devices()) os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config = config) start_time = clock.now() # Start Timer CLASSES = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'plus', 'minus', 'multiplication', 'division1'] NUM_CLASSES = len(CLASSES) # The number of classes IMG_SIZE = 28 # Pixel-Width of images BATCH_SIZE = 128 # The number of images to process during a single pass EPOCHS = 25 # The number of times to iterate through the entire training set IMG_ROWS, IMG_COLS = IMG_SIZE, IMG_SIZE # Input Image Dimensions DATA_UTILIZATION = 1 # Fraction of data which is utilized in training and testing TEST_RATIO = 1/6 DATA_FOLDER = "Data" dynamic_plotting = True plt.ion() # Define Keras callbacks to record and plot metrics