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
